summaryrefslogtreecommitdiff
path: root/rational.c
diff options
context:
space:
mode:
Diffstat (limited to 'rational.c')
-rw-r--r--rational.c887
1 files changed, 440 insertions, 447 deletions
diff --git a/rational.c b/rational.c
index 76a4264e0a..3b82016f32 100644
--- a/rational.c
+++ b/rational.c
@@ -15,8 +15,14 @@
#include <ieeefp.h>
#endif
+#if !defined(USE_GMP)
#if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
-#define USE_GMP
+# define USE_GMP 1
+#else
+# define USE_GMP 0
+#endif
+#endif
+#if USE_GMP
#include <gmp.h>
#endif
@@ -46,7 +52,6 @@ static ID id_abs, id_integer_p,
#define id_idiv idDiv
#define id_to_i idTo_i
-#define f_boolcast(x) ((x) ? Qtrue : Qfalse)
#define f_inspect rb_inspect
#define f_to_s rb_obj_as_string
@@ -57,9 +62,9 @@ inline static VALUE
f_add(VALUE x, VALUE y)
{
if (FIXNUM_ZERO_P(y))
- return x;
+ return x;
if (FIXNUM_ZERO_P(x))
- return y;
+ return y;
if (RB_INTEGER_TYPE_P(x))
return rb_int_plus(x, y);
return rb_funcall(x, '+', 1, y);
@@ -69,9 +74,9 @@ inline static VALUE
f_div(VALUE x, VALUE y)
{
if (y == ONE)
- return x;
+ return x;
if (RB_INTEGER_TYPE_P(x))
- return rb_int_div(x, y);
+ return rb_int_div(x, y);
return rb_funcall(x, '/', 1, y);
}
@@ -79,7 +84,7 @@ inline static int
f_lt_p(VALUE x, VALUE y)
{
if (FIXNUM_P(x) && FIXNUM_P(y))
- return (SIGNED_VALUE)x < (SIGNED_VALUE)y;
+ return (SIGNED_VALUE)x < (SIGNED_VALUE)y;
if (RB_INTEGER_TYPE_P(x)) {
VALUE r = rb_int_cmp(x, y);
if (!NIL_P(r)) return rb_int_negative_p(r);
@@ -102,13 +107,13 @@ inline static VALUE
f_mul(VALUE x, VALUE y)
{
if (FIXNUM_ZERO_P(y) && RB_INTEGER_TYPE_P(x))
- return ZERO;
+ return ZERO;
if (y == ONE) return x;
if (FIXNUM_ZERO_P(x) && RB_INTEGER_TYPE_P(y))
- return ZERO;
+ return ZERO;
if (x == ONE) return y;
else if (RB_INTEGER_TYPE_P(x))
- return rb_int_mul(x, y);
+ return rb_int_mul(x, y);
return rb_funcall(x, '*', 1, y);
}
@@ -116,7 +121,7 @@ inline static VALUE
f_sub(VALUE x, VALUE y)
{
if (FIXNUM_P(y) && FIXNUM_ZERO_P(y))
- return x;
+ return x;
return rb_funcall(x, '-', 1, y);
}
@@ -124,12 +129,12 @@ inline static VALUE
f_abs(VALUE x)
{
if (RB_INTEGER_TYPE_P(x))
- return rb_int_abs(x);
+ return rb_int_abs(x);
return rb_funcall(x, id_abs, 0);
}
-inline static VALUE
+inline static int
f_integer_p(VALUE x)
{
return RB_INTEGER_TYPE_P(x);
@@ -139,7 +144,7 @@ inline static VALUE
f_to_i(VALUE x)
{
if (RB_TYPE_P(x, T_STRING))
- return rb_str_to_inum(x, 10, 0);
+ return rb_str_to_inum(x, 10, 0);
return rb_funcall(x, id_to_i, 0);
}
@@ -147,7 +152,7 @@ inline static int
f_eqeq_p(VALUE x, VALUE y)
{
if (FIXNUM_P(x) && FIXNUM_P(y))
- return x == y;
+ return x == y;
if (RB_INTEGER_TYPE_P(x))
return RTEST(rb_int_equal(x, y));
return (int)rb_equal(x, y);
@@ -157,7 +162,7 @@ inline static VALUE
f_idiv(VALUE x, VALUE y)
{
if (RB_INTEGER_TYPE_P(x))
- return rb_int_idiv(x, y);
+ return rb_int_idiv(x, y);
return rb_funcall(x, id_idiv, 1, y);
}
@@ -167,12 +172,12 @@ inline static int
f_zero_p(VALUE x)
{
if (RB_INTEGER_TYPE_P(x)) {
- return FIXNUM_ZERO_P(x);
+ return FIXNUM_ZERO_P(x);
}
else if (RB_TYPE_P(x, T_RATIONAL)) {
- VALUE num = RRATIONAL(x)->num;
+ VALUE num = RRATIONAL(x)->num;
- return FIXNUM_ZERO_P(num);
+ return FIXNUM_ZERO_P(num);
}
return (int)rb_equal(x, ZERO);
}
@@ -183,13 +188,13 @@ inline static int
f_one_p(VALUE x)
{
if (RB_INTEGER_TYPE_P(x)) {
- return x == LONG2FIX(1);
+ return x == LONG2FIX(1);
}
else if (RB_TYPE_P(x, T_RATIONAL)) {
- VALUE num = RRATIONAL(x)->num;
- VALUE den = RRATIONAL(x)->den;
+ VALUE num = RRATIONAL(x)->num;
+ VALUE den = RRATIONAL(x)->den;
- return num == LONG2FIX(1) && den == LONG2FIX(1);
+ return num == LONG2FIX(1) && den == LONG2FIX(1);
}
return (int)rb_equal(x, ONE);
}
@@ -198,16 +203,16 @@ inline static int
f_minus_one_p(VALUE x)
{
if (RB_INTEGER_TYPE_P(x)) {
- return x == LONG2FIX(-1);
+ return x == LONG2FIX(-1);
}
- else if (RB_TYPE_P(x, T_BIGNUM)) {
- return Qfalse;
+ else if (RB_BIGNUM_TYPE_P(x)) {
+ return Qfalse;
}
else if (RB_TYPE_P(x, T_RATIONAL)) {
- VALUE num = RRATIONAL(x)->num;
- VALUE den = RRATIONAL(x)->den;
+ VALUE num = RRATIONAL(x)->num;
+ VALUE den = RRATIONAL(x)->den;
- return num == LONG2FIX(-1) && den == LONG2FIX(1);
+ return num == LONG2FIX(-1) && den == LONG2FIX(1);
}
return (int)rb_equal(x, INT2FIX(-1));
}
@@ -248,7 +253,7 @@ k_rational_p(VALUE x)
#define k_exact_zero_p(x) (k_exact_p(x) && f_zero_p(x))
#define k_exact_one_p(x) (k_exact_p(x) && f_one_p(x))
-#ifdef USE_GMP
+#if USE_GMP
VALUE
rb_gcd_gmp(VALUE x, VALUE y)
{
@@ -290,35 +295,35 @@ i_gcd(long x, long y)
int shift;
if (x < 0)
- x = -x;
+ x = -x;
if (y < 0)
- y = -y;
+ y = -y;
if (x == 0)
- return y;
+ return y;
if (y == 0)
- return x;
+ return x;
u = (unsigned long)x;
v = (unsigned long)y;
for (shift = 0; ((u | v) & 1) == 0; ++shift) {
- u >>= 1;
- v >>= 1;
+ u >>= 1;
+ v >>= 1;
}
while ((u & 1) == 0)
- u >>= 1;
+ u >>= 1;
do {
- while ((v & 1) == 0)
- v >>= 1;
-
- if (u > v) {
- t = v;
- v = u;
- u = t;
- }
- v = v - u;
+ while ((v & 1) == 0)
+ v >>= 1;
+
+ if (u > v) {
+ t = v;
+ v = u;
+ u = t;
+ }
+ v = v - u;
} while (v != 0);
return (long)(u << shift);
@@ -330,28 +335,28 @@ f_gcd_normal(VALUE x, VALUE y)
VALUE z;
if (FIXNUM_P(x) && FIXNUM_P(y))
- return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y)));
+ return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y)));
if (INT_NEGATIVE_P(x))
- x = rb_int_uminus(x);
+ x = rb_int_uminus(x);
if (INT_NEGATIVE_P(y))
- y = rb_int_uminus(y);
+ y = rb_int_uminus(y);
if (INT_ZERO_P(x))
- return y;
+ return y;
if (INT_ZERO_P(y))
- return x;
+ return x;
for (;;) {
- if (FIXNUM_P(x)) {
- if (FIXNUM_ZERO_P(x))
- return y;
- if (FIXNUM_P(y))
- return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y)));
- }
- z = x;
- x = rb_int_modulo(y, x);
- y = z;
+ if (FIXNUM_P(x)) {
+ if (FIXNUM_ZERO_P(x))
+ return y;
+ if (FIXNUM_P(y))
+ return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y)));
+ }
+ z = x;
+ x = rb_int_modulo(y, x);
+ y = z;
}
/* NOTREACHED */
}
@@ -365,8 +370,8 @@ rb_gcd_normal(VALUE x, VALUE y)
inline static VALUE
f_gcd(VALUE x, VALUE y)
{
-#ifdef USE_GMP
- if (RB_TYPE_P(x, T_BIGNUM) && RB_TYPE_P(y, T_BIGNUM)) {
+#if USE_GMP
+ if (RB_BIGNUM_TYPE_P(x) && RB_BIGNUM_TYPE_P(y)) {
size_t xn = BIGNUM_LEN(x);
size_t yn = BIGNUM_LEN(y);
if (GMP_GCD_DIGITS <= xn || GMP_GCD_DIGITS <= yn)
@@ -384,8 +389,8 @@ f_gcd(VALUE x, VALUE y)
{
VALUE r = f_gcd_orig(x, y);
if (f_nonzero_p(r)) {
- assert(f_zero_p(f_mod(x, r)));
- assert(f_zero_p(f_mod(y, r)));
+ RUBY_ASSERT(f_zero_p(f_mod(x, r)));
+ RUBY_ASSERT(f_zero_p(f_mod(y, r)));
}
return r;
}
@@ -395,7 +400,7 @@ inline static VALUE
f_lcm(VALUE x, VALUE y)
{
if (INT_ZERO_P(x) || INT_ZERO_P(y))
- return ZERO;
+ return ZERO;
return f_abs(f_mul(f_div(x, f_gcd(x, y)), y));
}
@@ -408,7 +413,8 @@ f_lcm(VALUE x, VALUE y)
inline static VALUE
nurat_s_new_internal(VALUE klass, VALUE num, VALUE den)
{
- NEWOBJ_OF(obj, struct RRational, klass, T_RATIONAL | (RGENGC_WB_PROTECTED_RATIONAL ? FL_WB_PROTECTED : 0));
+ NEWOBJ_OF(obj, struct RRational, klass, T_RATIONAL | (RGENGC_WB_PROTECTED_RATIONAL ? FL_WB_PROTECTED : 0),
+ sizeof(struct RRational), 0);
RATIONAL_SET_NUM((VALUE)obj, num);
RATIONAL_SET_DEN((VALUE)obj, den);
@@ -433,8 +439,8 @@ inline static void
nurat_int_check(VALUE num)
{
if (!RB_INTEGER_TYPE_P(num)) {
- if (!k_numeric_p(num) || !f_integer_p(num))
- rb_raise(rb_eTypeError, "not an integer");
+ if (!k_numeric_p(num) || !f_integer_p(num))
+ rb_raise(rb_eTypeError, "not an integer");
}
}
@@ -443,15 +449,15 @@ nurat_int_value(VALUE num)
{
nurat_int_check(num);
if (!k_integer_p(num))
- num = f_to_i(num);
+ num = f_to_i(num);
return num;
}
static void
nurat_canonicalize(VALUE *num, VALUE *den)
{
- assert(num); assert(RB_INTEGER_TYPE_P(*num));
- assert(den); assert(RB_INTEGER_TYPE_P(*den));
+ RUBY_ASSERT(num); RUBY_ASSERT(RB_INTEGER_TYPE_P(*num));
+ RUBY_ASSERT(den); RUBY_ASSERT(RB_INTEGER_TYPE_P(*den));
if (INT_NEGATIVE_P(*den)) {
*num = rb_int_uminus(*num);
*den = rb_int_uminus(*den);
@@ -491,16 +497,16 @@ nurat_s_canonicalize_internal_no_reduce(VALUE klass, VALUE num, VALUE den)
inline static VALUE
f_rational_new2(VALUE klass, VALUE x, VALUE y)
{
- assert(!k_rational_p(x));
- assert(!k_rational_p(y));
+ RUBY_ASSERT(!k_rational_p(x));
+ RUBY_ASSERT(!k_rational_p(y));
return nurat_s_canonicalize_internal(klass, x, y);
}
inline static VALUE
f_rational_new_no_reduce2(VALUE klass, VALUE x, VALUE y)
{
- assert(!k_rational_p(x));
- assert(!k_rational_p(y));
+ RUBY_ASSERT(!k_rational_p(x));
+ RUBY_ASSERT(!k_rational_p(y));
return nurat_s_canonicalize_internal_no_reduce(klass, x, y);
}
@@ -604,7 +610,7 @@ nurat_denominator(VALUE self)
VALUE
rb_rational_uminus(VALUE self)
{
- const int unused = (assert(RB_TYPE_P(self, T_RATIONAL)), 0);
+ const int unused = (RUBY_ASSERT(RB_TYPE_P(self, T_RATIONAL)), 0);
get_dat1(self);
(void)unused;
return f_rational_new2(CLASS_OF(self), rb_int_uminus(dat->num), dat->den);
@@ -620,14 +626,14 @@ f_imul(long a, long b)
VALUE r;
if (a == 0 || b == 0)
- return ZERO;
+ return ZERO;
else if (a == 1)
- return LONG2NUM(b);
+ return LONG2NUM(b);
else if (b == 1)
- return LONG2NUM(a);
+ return LONG2NUM(a);
if (MUL_OVERFLOW_LONG_P(a, b))
- r = rb_big_mul(rb_int2big(a), rb_int2big(b));
+ r = rb_big_mul(rb_int2big(a), rb_int2big(b));
else
r = LONG2NUM(a * b);
return r;
@@ -640,7 +646,7 @@ inline static VALUE
f_imul(long x, long y)
{
VALUE r = f_imul_orig(x, y);
- assert(f_eqeq_p(r, f_mul(LONG2NUM(x), LONG2NUM(y))));
+ RUBY_ASSERT(f_eqeq_p(r, f_mul(LONG2NUM(x), LONG2NUM(y))));
return r;
}
#endif
@@ -651,46 +657,46 @@ f_addsub(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k)
VALUE num, den;
if (FIXNUM_P(anum) && FIXNUM_P(aden) &&
- FIXNUM_P(bnum) && FIXNUM_P(bden)) {
- long an = FIX2LONG(anum);
- long ad = FIX2LONG(aden);
- long bn = FIX2LONG(bnum);
- long bd = FIX2LONG(bden);
- long ig = i_gcd(ad, bd);
-
- VALUE g = LONG2NUM(ig);
- VALUE a = f_imul(an, bd / ig);
- VALUE b = f_imul(bn, ad / ig);
- VALUE c;
-
- if (k == '+')
- c = rb_int_plus(a, b);
- else
- c = rb_int_minus(a, b);
-
- b = rb_int_idiv(aden, g);
- g = f_gcd(c, g);
- num = rb_int_idiv(c, g);
- a = rb_int_idiv(bden, g);
- den = rb_int_mul(a, b);
+ FIXNUM_P(bnum) && FIXNUM_P(bden)) {
+ long an = FIX2LONG(anum);
+ long ad = FIX2LONG(aden);
+ long bn = FIX2LONG(bnum);
+ long bd = FIX2LONG(bden);
+ long ig = i_gcd(ad, bd);
+
+ VALUE g = LONG2NUM(ig);
+ VALUE a = f_imul(an, bd / ig);
+ VALUE b = f_imul(bn, ad / ig);
+ VALUE c;
+
+ if (k == '+')
+ c = rb_int_plus(a, b);
+ else
+ c = rb_int_minus(a, b);
+
+ b = rb_int_idiv(aden, g);
+ g = f_gcd(c, g);
+ num = rb_int_idiv(c, g);
+ a = rb_int_idiv(bden, g);
+ den = rb_int_mul(a, b);
}
else if (RB_INTEGER_TYPE_P(anum) && RB_INTEGER_TYPE_P(aden) &&
RB_INTEGER_TYPE_P(bnum) && RB_INTEGER_TYPE_P(bden)) {
- VALUE g = f_gcd(aden, bden);
- VALUE a = rb_int_mul(anum, rb_int_idiv(bden, g));
- VALUE b = rb_int_mul(bnum, rb_int_idiv(aden, g));
- VALUE c;
-
- if (k == '+')
- c = rb_int_plus(a, b);
- else
- c = rb_int_minus(a, b);
-
- b = rb_int_idiv(aden, g);
- g = f_gcd(c, g);
- num = rb_int_idiv(c, g);
- a = rb_int_idiv(bden, g);
- den = rb_int_mul(a, b);
+ VALUE g = f_gcd(aden, bden);
+ VALUE a = rb_int_mul(anum, rb_int_idiv(bden, g));
+ VALUE b = rb_int_mul(bnum, rb_int_idiv(aden, g));
+ VALUE c;
+
+ if (k == '+')
+ c = rb_int_plus(a, b);
+ else
+ c = rb_int_minus(a, b);
+
+ b = rb_int_idiv(aden, g);
+ g = f_gcd(c, g);
+ num = rb_int_idiv(c, g);
+ a = rb_int_idiv(bden, g);
+ den = rb_int_mul(a, b);
}
else {
double a = NUM2DBL(anum) / NUM2DBL(aden);
@@ -718,28 +724,28 @@ VALUE
rb_rational_plus(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
- {
- get_dat1(self);
+ {
+ get_dat1(self);
- return f_rational_new_no_reduce2(CLASS_OF(self),
- rb_int_plus(dat->num, rb_int_mul(other, dat->den)),
- dat->den);
- }
+ return f_rational_new_no_reduce2(CLASS_OF(self),
+ rb_int_plus(dat->num, rb_int_mul(other, dat->den)),
+ dat->den);
+ }
}
else if (RB_FLOAT_TYPE_P(other)) {
- return DBL2NUM(nurat_to_double(self) + RFLOAT_VALUE(other));
+ return DBL2NUM(nurat_to_double(self) + RFLOAT_VALUE(other));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
- {
- get_dat2(self, other);
+ {
+ get_dat2(self, other);
- return f_addsub(self,
- adat->num, adat->den,
- bdat->num, bdat->den, '+');
- }
+ return f_addsub(self,
+ adat->num, adat->den,
+ bdat->num, bdat->den, '+');
+ }
}
else {
- return rb_num_coerce_bin(self, other, '+');
+ return rb_num_coerce_bin(self, other, '+');
}
}
@@ -759,28 +765,28 @@ VALUE
rb_rational_minus(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
- {
- get_dat1(self);
+ {
+ get_dat1(self);
- return f_rational_new_no_reduce2(CLASS_OF(self),
- rb_int_minus(dat->num, rb_int_mul(other, dat->den)),
- dat->den);
- }
+ return f_rational_new_no_reduce2(CLASS_OF(self),
+ rb_int_minus(dat->num, rb_int_mul(other, dat->den)),
+ dat->den);
+ }
}
else if (RB_FLOAT_TYPE_P(other)) {
- return DBL2NUM(nurat_to_double(self) - RFLOAT_VALUE(other));
+ return DBL2NUM(nurat_to_double(self) - RFLOAT_VALUE(other));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
- {
- get_dat2(self, other);
+ {
+ get_dat2(self, other);
- return f_addsub(self,
- adat->num, adat->den,
- bdat->num, bdat->den, '-');
- }
+ return f_addsub(self,
+ adat->num, adat->den,
+ bdat->num, bdat->den, '-');
+ }
}
else {
- return rb_num_coerce_bin(self, other, '-');
+ return rb_num_coerce_bin(self, other, '-');
}
}
@@ -789,7 +795,7 @@ f_muldiv(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k)
{
VALUE num, den;
- assert(RB_TYPE_P(self, T_RATIONAL));
+ RUBY_ASSERT(RB_TYPE_P(self, T_RATIONAL));
/* Integer#** can return Rational with Float right now */
if (RB_FLOAT_TYPE_P(anum) || RB_FLOAT_TYPE_P(aden) ||
@@ -800,41 +806,41 @@ f_muldiv(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k)
return DBL2NUM(x);
}
- assert(RB_INTEGER_TYPE_P(anum));
- assert(RB_INTEGER_TYPE_P(aden));
- assert(RB_INTEGER_TYPE_P(bnum));
- assert(RB_INTEGER_TYPE_P(bden));
+ RUBY_ASSERT(RB_INTEGER_TYPE_P(anum));
+ RUBY_ASSERT(RB_INTEGER_TYPE_P(aden));
+ RUBY_ASSERT(RB_INTEGER_TYPE_P(bnum));
+ RUBY_ASSERT(RB_INTEGER_TYPE_P(bden));
if (k == '/') {
- VALUE t;
+ VALUE t;
- if (INT_NEGATIVE_P(bnum)) {
- anum = rb_int_uminus(anum);
- bnum = rb_int_uminus(bnum);
- }
- t = bnum;
- bnum = bden;
- bden = t;
+ if (INT_NEGATIVE_P(bnum)) {
+ anum = rb_int_uminus(anum);
+ bnum = rb_int_uminus(bnum);
+ }
+ t = bnum;
+ bnum = bden;
+ bden = t;
}
if (FIXNUM_P(anum) && FIXNUM_P(aden) &&
- FIXNUM_P(bnum) && FIXNUM_P(bden)) {
- long an = FIX2LONG(anum);
- long ad = FIX2LONG(aden);
- long bn = FIX2LONG(bnum);
- long bd = FIX2LONG(bden);
- long g1 = i_gcd(an, bd);
- long g2 = i_gcd(ad, bn);
+ FIXNUM_P(bnum) && FIXNUM_P(bden)) {
+ long an = FIX2LONG(anum);
+ long ad = FIX2LONG(aden);
+ long bn = FIX2LONG(bnum);
+ long bd = FIX2LONG(bden);
+ long g1 = i_gcd(an, bd);
+ long g2 = i_gcd(ad, bn);
- num = f_imul(an / g1, bn / g2);
- den = f_imul(ad / g2, bd / g1);
+ num = f_imul(an / g1, bn / g2);
+ den = f_imul(ad / g2, bd / g1);
}
else {
- VALUE g1 = f_gcd(anum, bden);
- VALUE g2 = f_gcd(aden, bnum);
+ VALUE g1 = f_gcd(anum, bden);
+ VALUE g2 = f_gcd(aden, bnum);
- num = rb_int_mul(rb_int_idiv(anum, g1), rb_int_idiv(bnum, g2));
- den = rb_int_mul(rb_int_idiv(aden, g2), rb_int_idiv(bden, g1));
+ num = rb_int_mul(rb_int_idiv(anum, g1), rb_int_idiv(bnum, g2));
+ den = rb_int_mul(rb_int_idiv(aden, g2), rb_int_idiv(bden, g1));
}
return f_rational_new_no_reduce2(CLASS_OF(self), num, den);
}
@@ -855,28 +861,28 @@ VALUE
rb_rational_mul(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
- {
- get_dat1(self);
+ {
+ get_dat1(self);
- return f_muldiv(self,
- dat->num, dat->den,
- other, ONE, '*');
- }
+ return f_muldiv(self,
+ dat->num, dat->den,
+ other, ONE, '*');
+ }
}
else if (RB_FLOAT_TYPE_P(other)) {
- return DBL2NUM(nurat_to_double(self) * RFLOAT_VALUE(other));
+ return DBL2NUM(nurat_to_double(self) * RFLOAT_VALUE(other));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
- {
- get_dat2(self, other);
+ {
+ get_dat2(self, other);
- return f_muldiv(self,
- adat->num, adat->den,
- bdat->num, bdat->den, '*');
- }
+ return f_muldiv(self,
+ adat->num, adat->den,
+ bdat->num, bdat->den, '*');
+ }
}
else {
- return rb_num_coerce_bin(self, other, '*');
+ return rb_num_coerce_bin(self, other, '*');
}
}
@@ -897,37 +903,37 @@ VALUE
rb_rational_div(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
- if (f_zero_p(other))
+ if (f_zero_p(other))
rb_num_zerodiv();
- {
- get_dat1(self);
+ {
+ get_dat1(self);
- return f_muldiv(self,
- dat->num, dat->den,
- other, ONE, '/');
- }
+ return f_muldiv(self,
+ dat->num, dat->den,
+ other, ONE, '/');
+ }
}
else if (RB_FLOAT_TYPE_P(other)) {
VALUE v = nurat_to_f(self);
return rb_flo_div_flo(v, other);
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
- if (f_zero_p(other))
+ if (f_zero_p(other))
rb_num_zerodiv();
- {
- get_dat2(self, other);
+ {
+ get_dat2(self, other);
- if (f_one_p(self))
- return f_rational_new_no_reduce2(CLASS_OF(self),
- bdat->den, bdat->num);
+ if (f_one_p(self))
+ return f_rational_new_no_reduce2(CLASS_OF(self),
+ bdat->den, bdat->num);
- return f_muldiv(self,
- adat->num, adat->den,
- bdat->num, bdat->den, '/');
- }
+ return f_muldiv(self,
+ adat->num, adat->den,
+ bdat->num, bdat->den, '/');
+ }
}
else {
- return rb_num_coerce_bin(self, other, '/');
+ return rb_num_coerce_bin(self, other, '/');
}
}
@@ -948,12 +954,12 @@ nurat_fdiv(VALUE self, VALUE other)
if (f_zero_p(other))
return rb_rational_div(self, rb_float_new(0.0));
if (FIXNUM_P(other) && other == LONG2FIX(1))
- return nurat_to_f(self);
+ return nurat_to_f(self);
div = rb_rational_div(self, other);
if (RB_TYPE_P(div, T_RATIONAL))
- return nurat_to_f(div);
+ return nurat_to_f(div);
if (RB_FLOAT_TYPE_P(div))
- return div;
+ return div;
return rb_funcall(div, idTo_f, 0);
}
@@ -974,76 +980,76 @@ VALUE
rb_rational_pow(VALUE self, VALUE other)
{
if (k_numeric_p(other) && k_exact_zero_p(other))
- return f_rational_new_bang1(CLASS_OF(self), ONE);
+ return f_rational_new_bang1(CLASS_OF(self), ONE);
if (k_rational_p(other)) {
- get_dat1(other);
+ get_dat1(other);
- if (f_one_p(dat->den))
- other = dat->num; /* c14n */
+ if (f_one_p(dat->den))
+ other = dat->num; /* c14n */
}
/* Deal with special cases of 0**n and 1**n */
if (k_numeric_p(other) && k_exact_p(other)) {
- get_dat1(self);
- if (f_one_p(dat->den)) {
- if (f_one_p(dat->num)) {
- return f_rational_new_bang1(CLASS_OF(self), ONE);
- }
- else if (f_minus_one_p(dat->num) && RB_INTEGER_TYPE_P(other)) {
- return f_rational_new_bang1(CLASS_OF(self), INT2FIX(rb_int_odd_p(other) ? -1 : 1));
- }
- else if (INT_ZERO_P(dat->num)) {
- if (rb_num_negative_p(other)) {
+ get_dat1(self);
+ if (f_one_p(dat->den)) {
+ if (f_one_p(dat->num)) {
+ return f_rational_new_bang1(CLASS_OF(self), ONE);
+ }
+ else if (f_minus_one_p(dat->num) && RB_INTEGER_TYPE_P(other)) {
+ return f_rational_new_bang1(CLASS_OF(self), INT2FIX(rb_int_odd_p(other) ? -1 : 1));
+ }
+ else if (INT_ZERO_P(dat->num)) {
+ if (rb_num_negative_p(other)) {
rb_num_zerodiv();
- }
- else {
- return f_rational_new_bang1(CLASS_OF(self), ZERO);
- }
- }
- }
+ }
+ else {
+ return f_rational_new_bang1(CLASS_OF(self), ZERO);
+ }
+ }
+ }
}
/* General case */
if (FIXNUM_P(other)) {
- {
- VALUE num, den;
+ {
+ VALUE num, den;
- get_dat1(self);
+ get_dat1(self);
if (INT_POSITIVE_P(other)) {
- num = rb_int_pow(dat->num, other);
- den = rb_int_pow(dat->den, other);
+ num = rb_int_pow(dat->num, other);
+ den = rb_int_pow(dat->den, other);
}
else if (INT_NEGATIVE_P(other)) {
- num = rb_int_pow(dat->den, rb_int_uminus(other));
- den = rb_int_pow(dat->num, rb_int_uminus(other));
+ num = rb_int_pow(dat->den, rb_int_uminus(other));
+ den = rb_int_pow(dat->num, rb_int_uminus(other));
}
else {
- num = ONE;
- den = ONE;
- }
- if (RB_FLOAT_TYPE_P(num)) { /* infinity due to overflow */
- if (RB_FLOAT_TYPE_P(den))
- return DBL2NUM(nan(""));
- return num;
- }
- if (RB_FLOAT_TYPE_P(den)) { /* infinity due to overflow */
- num = ZERO;
- den = ONE;
- }
- return f_rational_new2(CLASS_OF(self), num, den);
- }
- }
- else if (RB_TYPE_P(other, T_BIGNUM)) {
- rb_warn("in a**b, b may be too big");
- return rb_float_pow(nurat_to_f(self), other);
+ num = ONE;
+ den = ONE;
+ }
+ if (RB_FLOAT_TYPE_P(num)) { /* infinity due to overflow */
+ if (RB_FLOAT_TYPE_P(den))
+ return DBL2NUM(nan(""));
+ return num;
+ }
+ if (RB_FLOAT_TYPE_P(den)) { /* infinity due to overflow */
+ num = ZERO;
+ den = ONE;
+ }
+ return f_rational_new2(CLASS_OF(self), num, den);
+ }
+ }
+ else if (RB_BIGNUM_TYPE_P(other)) {
+ rb_warn("in a**b, b may be too big");
+ return rb_float_pow(nurat_to_f(self), other);
}
else if (RB_FLOAT_TYPE_P(other) || RB_TYPE_P(other, T_RATIONAL)) {
- return rb_float_pow(nurat_to_f(self), other);
+ return rb_float_pow(nurat_to_f(self), other);
}
else {
- return rb_num_coerce_bin(self, other, idPow);
+ return rb_num_coerce_bin(self, other, idPow);
}
}
#define nurat_expt rb_rational_pow
@@ -1071,38 +1077,38 @@ rb_rational_cmp(VALUE self, VALUE other)
switch (TYPE(other)) {
case T_FIXNUM:
case T_BIGNUM:
- {
- get_dat1(self);
+ {
+ get_dat1(self);
- if (dat->den == LONG2FIX(1))
- return rb_int_cmp(dat->num, other); /* c14n */
- other = f_rational_new_bang1(CLASS_OF(self), other);
+ if (dat->den == LONG2FIX(1))
+ return rb_int_cmp(dat->num, other); /* c14n */
+ other = f_rational_new_bang1(CLASS_OF(self), other);
/* FALLTHROUGH */
- }
+ }
case T_RATIONAL:
- {
- VALUE num1, num2;
-
- get_dat2(self, other);
-
- if (FIXNUM_P(adat->num) && FIXNUM_P(adat->den) &&
- FIXNUM_P(bdat->num) && FIXNUM_P(bdat->den)) {
- num1 = f_imul(FIX2LONG(adat->num), FIX2LONG(bdat->den));
- num2 = f_imul(FIX2LONG(bdat->num), FIX2LONG(adat->den));
- }
- else {
- num1 = rb_int_mul(adat->num, bdat->den);
- num2 = rb_int_mul(bdat->num, adat->den);
- }
- return rb_int_cmp(rb_int_minus(num1, num2), ZERO);
- }
+ {
+ VALUE num1, num2;
+
+ get_dat2(self, other);
+
+ if (FIXNUM_P(adat->num) && FIXNUM_P(adat->den) &&
+ FIXNUM_P(bdat->num) && FIXNUM_P(bdat->den)) {
+ num1 = f_imul(FIX2LONG(adat->num), FIX2LONG(bdat->den));
+ num2 = f_imul(FIX2LONG(bdat->num), FIX2LONG(adat->den));
+ }
+ else {
+ num1 = rb_int_mul(adat->num, bdat->den);
+ num2 = rb_int_mul(bdat->num, adat->den);
+ }
+ return rb_int_cmp(rb_int_minus(num1, num2), ZERO);
+ }
case T_FLOAT:
return rb_dbl_cmp(nurat_to_double(self), RFLOAT_VALUE(other));
default:
- return rb_num_coerce_cmp(self, other, idCmp);
+ return rb_num_coerce_cmp(self, other, idCmp);
}
}
@@ -1125,37 +1131,37 @@ nurat_eqeq_p(VALUE self, VALUE other)
get_dat1(self);
if (RB_INTEGER_TYPE_P(dat->num) && RB_INTEGER_TYPE_P(dat->den)) {
- if (INT_ZERO_P(dat->num) && INT_ZERO_P(other))
- return Qtrue;
-
- if (!FIXNUM_P(dat->den))
- return Qfalse;
- if (FIX2LONG(dat->den) != 1)
- return Qfalse;
- return rb_int_equal(dat->num, other);
- }
+ if (INT_ZERO_P(dat->num) && INT_ZERO_P(other))
+ return Qtrue;
+
+ if (!FIXNUM_P(dat->den))
+ return Qfalse;
+ if (FIX2LONG(dat->den) != 1)
+ return Qfalse;
+ return rb_int_equal(dat->num, other);
+ }
else {
const double d = nurat_to_double(self);
- return f_boolcast(FIXNUM_ZERO_P(rb_dbl_cmp(d, NUM2DBL(other))));
+ return RBOOL(FIXNUM_ZERO_P(rb_dbl_cmp(d, NUM2DBL(other))));
}
}
else if (RB_FLOAT_TYPE_P(other)) {
- const double d = nurat_to_double(self);
- return f_boolcast(FIXNUM_ZERO_P(rb_dbl_cmp(d, RFLOAT_VALUE(other))));
+ const double d = nurat_to_double(self);
+ return RBOOL(FIXNUM_ZERO_P(rb_dbl_cmp(d, RFLOAT_VALUE(other))));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
- {
- get_dat2(self, other);
+ {
+ get_dat2(self, other);
- if (INT_ZERO_P(adat->num) && INT_ZERO_P(bdat->num))
- return Qtrue;
+ if (INT_ZERO_P(adat->num) && INT_ZERO_P(bdat->num))
+ return Qtrue;
- return f_boolcast(rb_int_equal(adat->num, bdat->num) &&
- rb_int_equal(adat->den, bdat->den));
- }
+ return RBOOL(rb_int_equal(adat->num, bdat->num) &&
+ rb_int_equal(adat->den, bdat->den));
+ }
}
else {
- return rb_equal(other, self);
+ return rb_equal(other, self);
}
}
@@ -1164,17 +1170,17 @@ static VALUE
nurat_coerce(VALUE self, VALUE other)
{
if (RB_INTEGER_TYPE_P(other)) {
- return rb_assoc_new(f_rational_new_bang1(CLASS_OF(self), other), self);
+ return rb_assoc_new(f_rational_new_bang1(CLASS_OF(self), other), self);
}
else if (RB_FLOAT_TYPE_P(other)) {
return rb_assoc_new(other, nurat_to_f(self));
}
else if (RB_TYPE_P(other, T_RATIONAL)) {
- return rb_assoc_new(other, self);
+ return rb_assoc_new(other, self);
}
else if (RB_TYPE_P(other, T_COMPLEX)) {
- if (!k_exact_zero_p(RCOMPLEX(other)->imag))
- return rb_assoc_new(other, rb_Complex(self, INT2FIX(0)));
+ if (!k_exact_zero_p(RCOMPLEX(other)->imag))
+ return rb_assoc_new(other, rb_Complex(self, INT2FIX(0)));
other = RCOMPLEX(other)->real;
if (RB_FLOAT_TYPE_P(other)) {
other = float_to_r(other);
@@ -1187,7 +1193,7 @@ nurat_coerce(VALUE self, VALUE other)
}
rb_raise(rb_eTypeError, "%s can't be coerced into %s",
- rb_obj_classname(other), rb_obj_classname(self));
+ rb_obj_classname(other), rb_obj_classname(self));
return Qnil;
}
@@ -1201,7 +1207,7 @@ static VALUE
nurat_positive_p(VALUE self)
{
get_dat1(self);
- return f_boolcast(INT_POSITIVE_P(dat->num));
+ return RBOOL(INT_POSITIVE_P(dat->num));
}
/*
@@ -1214,7 +1220,7 @@ static VALUE
nurat_negative_p(VALUE self)
{
get_dat1(self);
- return f_boolcast(INT_NEGATIVE_P(dat->num));
+ return RBOOL(INT_NEGATIVE_P(dat->num));
}
/*
@@ -1227,7 +1233,6 @@ nurat_negative_p(VALUE self)
* (1/2r).abs #=> (1/2)
* (-1/2r).abs #=> (1/2)
*
- * Rational#magnitude is an alias for Rational#abs.
*/
VALUE
@@ -1274,7 +1279,7 @@ nurat_truncate(VALUE self)
{
get_dat1(self);
if (INT_NEGATIVE_P(dat->num))
- return rb_int_uminus(rb_int_idiv(rb_int_uminus(dat->num), dat->den));
+ return rb_int_uminus(rb_int_idiv(rb_int_uminus(dat->num), dat->den));
return rb_int_idiv(dat->num, dat->den);
}
@@ -1290,14 +1295,14 @@ nurat_round_half_up(VALUE self)
neg = INT_NEGATIVE_P(num);
if (neg)
- num = rb_int_uminus(num);
+ num = rb_int_uminus(num);
num = rb_int_plus(rb_int_mul(num, TWO), den);
den = rb_int_mul(den, TWO);
num = rb_int_idiv(num, den);
if (neg)
- num = rb_int_uminus(num);
+ num = rb_int_uminus(num);
return num;
}
@@ -1314,7 +1319,7 @@ nurat_round_half_down(VALUE self)
neg = INT_NEGATIVE_P(num);
if (neg)
- num = rb_int_uminus(num);
+ num = rb_int_uminus(num);
num = rb_int_plus(rb_int_mul(num, TWO), den);
num = rb_int_minus(num, ONE);
@@ -1322,7 +1327,7 @@ nurat_round_half_down(VALUE self)
num = rb_int_idiv(num, den);
if (neg)
- num = rb_int_uminus(num);
+ num = rb_int_uminus(num);
return num;
}
@@ -1339,17 +1344,17 @@ nurat_round_half_even(VALUE self)
neg = INT_NEGATIVE_P(num);
if (neg)
- num = rb_int_uminus(num);
+ num = rb_int_uminus(num);
num = rb_int_plus(rb_int_mul(num, TWO), den);
den = rb_int_mul(den, TWO);
qr = rb_int_divmod(num, den);
num = RARRAY_AREF(qr, 0);
if (INT_ZERO_P(RARRAY_AREF(qr, 1)))
- num = rb_int_and(num, LONG2FIX(((int)~1)));
+ num = rb_int_and(num, LONG2FIX(((int)~1)));
if (neg)
- num = rb_int_uminus(num);
+ num = rb_int_uminus(num);
return num;
}
@@ -1360,24 +1365,24 @@ f_round_common(int argc, VALUE *argv, VALUE self, VALUE (*func)(VALUE))
VALUE n, b, s;
if (rb_check_arity(argc, 0, 1) == 0)
- return (*func)(self);
+ return (*func)(self);
n = argv[0];
if (!k_integer_p(n))
- rb_raise(rb_eTypeError, "not an integer");
+ rb_raise(rb_eTypeError, "not an integer");
b = f_expt10(n);
s = rb_rational_mul(self, b);
if (k_float_p(s)) {
- if (INT_NEGATIVE_P(n))
- return ZERO;
- return self;
+ if (INT_NEGATIVE_P(n))
+ return ZERO;
+ return self;
}
if (!k_rational_p(s)) {
- s = f_rational_new_bang1(CLASS_OF(self), s);
+ s = f_rational_new_bang1(CLASS_OF(self), s);
}
s = (*func)(s);
@@ -1385,7 +1390,7 @@ f_round_common(int argc, VALUE *argv, VALUE self, VALUE (*func)(VALUE))
s = rb_rational_div(f_rational_new_bang1(CLASS_OF(self), s), b);
if (RB_TYPE_P(s, T_RATIONAL) && FIX2INT(rb_int_cmp(n, ONE)) < 0)
- s = nurat_truncate(s);
+ s = nurat_truncate(s);
return s;
}
@@ -1535,11 +1540,17 @@ nurat_round_n(int argc, VALUE *argv, VALUE self)
VALUE opt;
enum ruby_num_rounding_mode mode = (
argc = rb_scan_args(argc, argv, "*:", NULL, &opt),
- rb_num_get_rounding_option(opt));
+ rb_num_get_rounding_option(opt));
VALUE (*round_func)(VALUE) = ROUND_FUNC(mode, nurat_round);
return f_round_common(argc, argv, self, round_func);
}
+VALUE
+rb_flo_round_by_rational(int argc, VALUE *argv, VALUE num)
+{
+ return nurat_to_f(nurat_round_n(argc, argv, float_to_r(num)));
+}
+
static double
nurat_to_double(VALUE self)
{
@@ -1678,19 +1689,19 @@ nurat_rationalize_internal(VALUE a, VALUE b, VALUE *p, VALUE *q)
q1 = ZERO;
while (1) {
- c = f_ceil(a);
- if (f_lt_p(c, b))
- break;
- k = f_sub(c, ONE);
- p2 = f_add(f_mul(k, p1), p0);
- q2 = f_add(f_mul(k, q1), q0);
- t = f_reciprocal(f_sub(b, k));
- b = f_reciprocal(f_sub(a, k));
- a = t;
- p0 = p1;
- q0 = q1;
- p1 = p2;
- q1 = q2;
+ c = f_ceil(a);
+ if (f_lt_p(c, b))
+ break;
+ k = f_sub(c, ONE);
+ p2 = f_add(f_mul(k, p1), p0);
+ q2 = f_add(f_mul(k, q1), q0);
+ t = f_reciprocal(f_sub(b, k));
+ b = f_reciprocal(f_sub(a, k));
+ a = t;
+ p0 = p1;
+ q0 = q1;
+ p1 = p2;
+ q1 = q2;
}
*p = f_add(f_mul(c, p1), p0);
*q = f_add(f_mul(c, q1), q0);
@@ -1718,7 +1729,7 @@ nurat_rationalize(int argc, VALUE *argv, VALUE self)
get_dat1(self);
if (rb_check_arity(argc, 0, 1) == 0)
- return self;
+ return self;
e = f_abs(argv[0]);
@@ -1730,7 +1741,7 @@ nurat_rationalize(int argc, VALUE *argv, VALUE self)
b = FIXNUM_ZERO_P(e) ? rat : rb_rational_plus(rat, e);
if (f_eqeq_p(a, b))
- return self;
+ return self;
nurat_rationalize_internal(a, b, &p, &q);
if (rat != self) {
@@ -1863,7 +1874,7 @@ nurat_marshal_load(VALUE self, VALUE a)
Check_Type(a, T_ARRAY);
if (RARRAY_LEN(a) != 2)
- rb_raise(rb_eArgError, "marshaled rational must have an array whose length is 2 but %ld", RARRAY_LEN(a));
+ rb_raise(rb_eArgError, "marshaled rational must have an array whose length is 2 but %ld", RARRAY_LEN(a));
num = RARRAY_AREF(a, 0);
den = RARRAY_AREF(a, 1);
@@ -1876,8 +1887,6 @@ nurat_marshal_load(VALUE self, VALUE a)
return self;
}
-/* --- */
-
VALUE
rb_rational_reciprocal(VALUE x)
{
@@ -2052,30 +2061,6 @@ rb_rational_canonicalize(VALUE x)
/*
* call-seq:
- * int.numerator -> self
- *
- * Returns self.
- */
-static VALUE
-integer_numerator(VALUE self)
-{
- return self;
-}
-
-/*
- * call-seq:
- * int.denominator -> 1
- *
- * Returns 1.
- */
-static VALUE
-integer_denominator(VALUE self)
-{
- return INT2FIX(1);
-}
-
-/*
- * call-seq:
* flo.numerator -> integer
*
* Returns the numerator. The result is machine dependent.
@@ -2091,8 +2076,8 @@ rb_float_numerator(VALUE self)
{
double d = RFLOAT_VALUE(self);
VALUE r;
- if (isinf(d) || isnan(d))
- return self;
+ if (!isfinite(d))
+ return self;
r = float_to_r(self);
return nurat_numerator(r);
}
@@ -2111,17 +2096,20 @@ rb_float_denominator(VALUE self)
{
double d = RFLOAT_VALUE(self);
VALUE r;
- if (isinf(d) || isnan(d))
- return INT2FIX(1);
+ if (!isfinite(d))
+ return INT2FIX(1);
r = float_to_r(self);
return nurat_denominator(r);
}
/*
* call-seq:
- * nil.to_r -> (0/1)
+ * to_r -> (0/1)
+ *
+ * Returns zero as a Rational:
+ *
+ * nil.to_r # => (0/1)
*
- * Returns zero as a rational.
*/
static VALUE
nilclass_to_r(VALUE self)
@@ -2131,10 +2119,14 @@ nilclass_to_r(VALUE self)
/*
* call-seq:
- * nil.rationalize([eps]) -> (0/1)
+ * rationalize(eps = nil) -> (0/1)
+ *
+ * Returns zero as a Rational:
+ *
+ * nil.rationalize # => (0/1)
+ *
+ * Argument +eps+ is ignored.
*
- * Returns zero as a rational. The optional argument +eps+ is always
- * ignored.
*/
static VALUE
nilclass_rationalize(int argc, VALUE *argv, VALUE self)
@@ -2220,7 +2212,7 @@ float_to_r(VALUE self)
#else
f = rb_int_mul(f, rb_int_pow(INT2FIX(FLT_RADIX), n));
if (RB_TYPE_P(f, T_RATIONAL))
- return f;
+ return f;
return rb_rational_new1(f);
#endif
}
@@ -2318,8 +2310,8 @@ read_sign(const char **s, const char *const e)
int sign = '?';
if (*s < e && issign(**s)) {
- sign = **s;
- (*s)++;
+ sign = **s;
+ (*s)++;
}
return sign;
}
@@ -2334,11 +2326,11 @@ static VALUE
negate_num(VALUE num)
{
if (FIXNUM_P(num)) {
- return rb_int_uminus(num);
+ return rb_int_uminus(num);
}
else {
- BIGNUM_NEGATE(num);
- return rb_big_norm(num);
+ BIGNUM_NEGATE(num);
+ return rb_big_norm(num);
}
}
@@ -2352,51 +2344,51 @@ read_num(const char **s, const char *const end, VALUE *num, VALUE *nexp)
*nexp = ZERO;
*num = ZERO;
if (*s < end && **s != '.') {
- n = rb_int_parse_cstr(*s, end-*s, &e, NULL,
- 10, RB_INT_PARSE_UNDERSCORE);
- if (NIL_P(n))
- return 0;
- *s = e;
- *num = n;
- ok = 1;
+ n = rb_int_parse_cstr(*s, end-*s, &e, NULL,
+ 10, RB_INT_PARSE_UNDERSCORE);
+ if (NIL_P(n))
+ return 0;
+ *s = e;
+ *num = n;
+ ok = 1;
}
if (*s < end && **s == '.') {
- size_t count = 0;
-
- (*s)++;
- fp = rb_int_parse_cstr(*s, end-*s, &e, &count,
- 10, RB_INT_PARSE_UNDERSCORE);
- if (NIL_P(fp))
- return 1;
- *s = e;
- {
+ size_t count = 0;
+
+ (*s)++;
+ fp = rb_int_parse_cstr(*s, end-*s, &e, &count,
+ 10, RB_INT_PARSE_UNDERSCORE);
+ if (NIL_P(fp))
+ return 1;
+ *s = e;
+ {
VALUE l = f_expt10(*nexp = SIZET2NUM(count));
- n = n == ZERO ? fp : rb_int_plus(rb_int_mul(*num, l), fp);
- *num = n;
- fn = SIZET2NUM(count);
- }
- ok = 1;
+ n = n == ZERO ? fp : rb_int_plus(rb_int_mul(*num, l), fp);
+ *num = n;
+ fn = SIZET2NUM(count);
+ }
+ ok = 1;
}
if (ok && *s + 1 < end && islettere(**s)) {
- (*s)++;
- expsign = read_sign(s, end);
- exp = rb_int_parse_cstr(*s, end-*s, &e, NULL,
- 10, RB_INT_PARSE_UNDERSCORE);
- if (NIL_P(exp))
- return 1;
- *s = e;
- if (exp != ZERO) {
- if (expsign == '-') {
- if (fn != ZERO) exp = rb_int_plus(exp, fn);
- }
- else {
- if (fn != ZERO) exp = rb_int_minus(exp, fn);
+ (*s)++;
+ expsign = read_sign(s, end);
+ exp = rb_int_parse_cstr(*s, end-*s, &e, NULL,
+ 10, RB_INT_PARSE_UNDERSCORE);
+ if (NIL_P(exp))
+ return 1;
+ *s = e;
+ if (exp != ZERO) {
+ if (expsign == '-') {
+ if (fn != ZERO) exp = rb_int_plus(exp, fn);
+ }
+ else {
+ if (fn != ZERO) exp = rb_int_minus(exp, fn);
exp = negate_num(exp);
- }
+ }
*nexp = exp;
- }
+ }
}
return ok;
@@ -2406,7 +2398,7 @@ inline static const char *
skip_ws(const char *s, const char *e)
{
while (s < e && isspace((unsigned char)*s))
- ++s;
+ ++s;
return s;
}
@@ -2420,30 +2412,30 @@ parse_rat(const char *s, const char *const e, int strict, int raise)
sign = read_sign(&s, e);
if (!read_num(&s, e, &num, &nexp)) {
- if (strict) return Qnil;
- return nurat_s_alloc(rb_cRational);
+ if (strict) return Qnil;
+ return nurat_s_alloc(rb_cRational);
}
den = ONE;
if (s < e && *s == '/') {
- s++;
+ s++;
if (!read_num(&s, e, &den, &dexp)) {
- if (strict) return Qnil;
+ if (strict) return Qnil;
den = ONE;
- }
- else if (den == ZERO) {
+ }
+ else if (den == ZERO) {
if (!raise) return Qnil;
- rb_num_zerodiv();
- }
- else if (strict && skip_ws(s, e) != e) {
- return Qnil;
- }
- else {
+ rb_num_zerodiv();
+ }
+ else if (strict && skip_ws(s, e) != e) {
+ return Qnil;
+ }
+ else {
nexp = rb_int_minus(nexp, dexp);
- nurat_reduce(&num, &den);
- }
+ nurat_reduce(&num, &den);
+ }
}
else if (strict && skip_ws(s, e) != e) {
- return Qnil;
+ return Qnil;
}
if (nexp != ZERO) {
@@ -2474,7 +2466,7 @@ parse_rat(const char *s, const char *const e, int strict, int raise)
}
if (sign == '-') {
- num = negate_num(num);
+ num = negate_num(num);
}
return rb_rational_raw(num, den);
@@ -2539,7 +2531,7 @@ string_to_r(VALUE self)
num = parse_rat(RSTRING_PTR(self), RSTRING_END(self), 0, TRUE);
if (RB_FLOAT_TYPE_P(num) && !FLOAT_ZERO_P(num))
- rb_raise(rb_eFloatDomainError, "Infinity");
+ rb_raise(rb_eFloatDomainError, "Infinity");
return num;
}
@@ -2551,7 +2543,7 @@ rb_cstr_to_rat(const char *s, int strict) /* for complex's internal */
num = parse_rat(s, s + strlen(s), strict, TRUE);
if (RB_FLOAT_TYPE_P(num) && !FLOAT_ZERO_P(num))
- rb_raise(rb_eFloatDomainError, "Infinity");
+ rb_raise(rb_eFloatDomainError, "Infinity");
return num;
}
@@ -2567,7 +2559,7 @@ nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise)
VALUE a1 = numv, a2 = denv;
int state;
- assert(a1 != Qundef);
+ RUBY_ASSERT(!UNDEF_P(a1));
if (NIL_P(a1) || NIL_P(a2)) {
if (!raise) return Qnil;
@@ -2618,7 +2610,7 @@ nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise)
a2 = string_to_r_strict(a2, raise);
if (!raise && NIL_P(a2)) return Qnil;
}
- else if (a2 != Qundef && !rb_respond_to(a2, idTo_r)) {
+ else if (!UNDEF_P(a2) && !rb_respond_to(a2, idTo_r)) {
VALUE tmp = rb_protect(rb_check_to_int, a2, NULL);
rb_set_errinfo(Qnil);
if (!NIL_P(tmp)) {
@@ -2627,11 +2619,11 @@ nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise)
}
if (RB_TYPE_P(a1, T_RATIONAL)) {
- if (a2 == Qundef || (k_exact_one_p(a2)))
+ if (UNDEF_P(a2) || (k_exact_one_p(a2)))
return a1;
}
- if (a2 == Qundef) {
+ if (UNDEF_P(a2)) {
if (!RB_INTEGER_TYPE_P(a1)) {
if (!raise) {
VALUE result = rb_protect(to_rational, a1, NULL);
@@ -2681,7 +2673,7 @@ nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise)
a1 = nurat_int_value(a1);
- if (a2 == Qundef) {
+ if (UNDEF_P(a2)) {
a2 = ONE;
}
else if (!k_integer_p(a2) && !raise) {
@@ -2712,13 +2704,19 @@ nurat_s_convert(int argc, VALUE *argv, VALUE klass)
* a/b (b>0), where a is the numerator and b is the denominator.
* Integer a equals rational a/1 mathematically.
*
- * In Ruby, you can create rational objects with the Kernel#Rational,
- * to_r, or rationalize methods or by suffixing +r+ to a literal.
- * The return values will be irreducible fractions.
+ * You can create a \Rational object explicitly with:
+ *
+ * - A {rational literal}[rdoc-ref:syntax/literals.rdoc@Rational+Literals].
+ *
+ * You can convert certain objects to Rationals with:
+ *
+ * - \Method #Rational.
+ *
+ * Examples
*
* Rational(1) #=> (1/1)
* Rational(2, 3) #=> (2/3)
- * Rational(4, -6) #=> (-2/3)
+ * Rational(4, -6) #=> (-2/3) # Reduced.
* 3.to_r #=> (3/1)
* 2/3r #=> (2/3)
*
@@ -2809,8 +2807,6 @@ Init_Rational(void)
rb_define_private_method(compat, "marshal_load", nurat_marshal_load, 1);
rb_marshal_define_compat(rb_cRational, compat, nurat_dumper, nurat_loader);
- /* --- */
-
rb_define_method(rb_cInteger, "gcd", rb_gcd, 1);
rb_define_method(rb_cInteger, "lcm", rb_lcm, 1);
rb_define_method(rb_cInteger, "gcdlcm", rb_gcdlcm, 1);
@@ -2819,9 +2815,6 @@ Init_Rational(void)
rb_define_method(rb_cNumeric, "denominator", numeric_denominator, 0);
rb_define_method(rb_cNumeric, "quo", rb_numeric_quo, 1);
- rb_define_method(rb_cInteger, "numerator", integer_numerator, 0);
- rb_define_method(rb_cInteger, "denominator", integer_denominator, 0);
-
rb_define_method(rb_cFloat, "numerator", rb_float_numerator, 0);
rb_define_method(rb_cFloat, "denominator", rb_float_denominator, 0);