diff options
Diffstat (limited to 'rational.c')
| -rw-r--r-- | rational.c | 1120 |
1 files changed, 563 insertions, 557 deletions
diff --git a/rational.c b/rational.c index d621773838..b031838d69 100644 --- a/rational.c +++ b/rational.c @@ -15,23 +15,34 @@ #include <ieeefp.h> #endif +#if !defined(USE_GMP) #if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H) -#define USE_GMP -#include <gmp.h> +# define USE_GMP 1 +#else +# define USE_GMP 0 +#endif #endif -#undef NDEBUG -#define NDEBUG #include "id.h" #include "internal.h" #include "internal/array.h" #include "internal/complex.h" +#include "internal/error.h" #include "internal/gc.h" #include "internal/numeric.h" #include "internal/object.h" #include "internal/rational.h" #include "ruby_assert.h" +#if USE_GMP +RBIMPL_WARNING_PUSH() +# ifdef _MSC_VER +RBIMPL_WARNING_IGNORED(4146) /* for mpn_neg() */ +# endif +# include <gmp.h> +RBIMPL_WARNING_POP() +#endif + #define ZERO INT2FIX(0) #define ONE INT2FIX(1) #define TWO INT2FIX(2) @@ -48,7 +59,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 @@ -59,9 +69,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); @@ -71,9 +81,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); } @@ -81,7 +91,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); @@ -104,13 +114,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); } @@ -118,7 +128,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); } @@ -126,12 +136,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); @@ -141,7 +151,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); } @@ -149,7 +159,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); @@ -159,39 +169,23 @@ 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); } #define f_expt10(x) rb_int_pow(INT2FIX(10), x) inline static int -f_zero_p(VALUE x) -{ - if (RB_INTEGER_TYPE_P(x)) { - return FIXNUM_ZERO_P(x); - } - else if (RB_TYPE_P(x, T_RATIONAL)) { - VALUE num = RRATIONAL(x)->num; - - return FIXNUM_ZERO_P(num); - } - return (int)rb_equal(x, ZERO); -} - -#define f_nonzero_p(x) (!f_zero_p(x)) - -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); } @@ -200,16 +194,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)); } @@ -250,7 +244,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) { @@ -292,35 +286,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); @@ -332,28 +326,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 */ } @@ -367,8 +361,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) @@ -386,8 +380,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; } @@ -397,7 +391,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)); } @@ -410,11 +404,11 @@ 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, sizeof(struct RRational)); RATIONAL_SET_NUM((VALUE)obj, num); RATIONAL_SET_DEN((VALUE)obj, den); - OBJ_FREEZE_RAW((VALUE)obj); + OBJ_FREEZE((VALUE)obj); return (VALUE)obj; } @@ -435,8 +429,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"); } } @@ -445,15 +439,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); @@ -493,16 +487,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); } @@ -599,14 +593,18 @@ nurat_denominator(VALUE self) /* * call-seq: - * -rat -> rational + * -self -> rational + * + * Returns +self+, negated: + * + * -(1/3r) # => (-1/3) + * -(-1/3r) # => (1/3) * - * Negates +rat+. */ 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); @@ -622,14 +620,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; @@ -642,7 +640,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 @@ -653,46 +651,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); @@ -705,51 +703,62 @@ f_addsub(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k) static double nurat_to_double(VALUE self); /* - * call-seq: - * rat + numeric -> numeric + * call-seq: + * self + other -> numeric * - * Performs addition. + * Returns the sum of +self+ and +other+: + * + * Rational(2, 3) + 0 # => (2/3) + * Rational(2, 3) + 1 # => (5/3) + * Rational(2, 3) + -1 # => (-1/3) + * + * Rational(2, 3) + Complex(1, 0) # => ((5/3)+0i) + * + * Rational(2, 3) + Rational(1, 1) # => (5/3) + * Rational(2, 3) + Rational(3, 2) # => (13/6) + * Rational(2, 3) + Rational(3.0, 2.0) # => (13/6) + * Rational(2, 3) + Rational(3.1, 2.1) # => (30399297484750849/14186338826217063) + * + * For a computation involving Floats, the result may be inexact (see Float#+): + * + * Rational(2, 3) + 1.0 # => 1.6666666666666665 + * Rational(2, 3) + Complex(1.0, 0.0) # => (1.6666666666666665+0.0i) * - * Rational(2, 3) + Rational(2, 3) #=> (4/3) - * Rational(900) + Rational(1) #=> (901/1) - * Rational(-2, 9) + Rational(-9, 2) #=> (-85/18) - * Rational(9, 8) + 4 #=> (41/8) - * Rational(20, 9) + 9.8 #=> 12.022222222222222 */ 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, '+'); } } /* * call-seq: - * rat - numeric -> numeric + * self - other -> numeric * - * Performs subtraction. + * Returns the difference of +self+ and +other+: * * Rational(2, 3) - Rational(2, 3) #=> (0/1) * Rational(900) - Rational(1) #=> (899/1) @@ -761,28 +770,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, '-'); } } @@ -791,7 +800,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) || @@ -802,92 +811,93 @@ 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); } /* * call-seq: - * rat * numeric -> numeric + * self * other -> numeric * - * Performs multiplication. + * Returns the numeric product of +self+ and +other+: + * + * Rational(9, 8) * 4 #=> (9/2) + * Rational(20, 9) * 9.8 #=> 21.77777777777778 + * Rational(9, 8) * Complex(1, 2) # => ((9/8)+(9/4)*i) + * Rational(2, 3) * Rational(2, 3) #=> (4/9) + * Rational(900) * Rational(1) #=> (900/1) + * Rational(-2, 9) * Rational(-9, 2) #=> (1/1) * - * Rational(2, 3) * Rational(2, 3) #=> (4/9) - * Rational(900) * Rational(1) #=> (900/1) - * Rational(-2, 9) * Rational(-9, 2) #=> (1/1) - * Rational(9, 8) * 4 #=> (9/2) - * Rational(20, 9) * 9.8 #=> 21.77777777777778 */ 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, '*'); } } /* * call-seq: - * rat / numeric -> numeric - * rat.quo(numeric) -> numeric + * self / other -> numeric * - * Performs division. + * Returns the quotient of +self+ and +other+: * * Rational(2, 3) / Rational(2, 3) #=> (1/1) * Rational(900) / Rational(1) #=> (900/1) @@ -899,37 +909,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, '/'); } } @@ -943,27 +953,27 @@ rb_rational_div(VALUE self, VALUE other) * Rational(2, 3).fdiv(0.5) #=> 1.3333333333333333 * Rational(2).fdiv(3) #=> 0.6666666666666666 */ -static VALUE -nurat_fdiv(VALUE self, VALUE other) +VALUE +rb_rational_fdiv(VALUE self, VALUE other) { VALUE div; 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); } /* * call-seq: - * rat ** numeric -> numeric + * self ** exponent -> numeric * - * Performs exponentiation. + * Returns +self+ raised to the power +exponent+: * * Rational(2) ** Rational(3) #=> (8/1) * Rational(10) ** -2 #=> (1/100) @@ -976,96 +986,105 @@ 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_raise(rb_eArgError, "exponent is too large"); } 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, rb_intern("**")); + return rb_num_coerce_bin(self, other, idPow); } } #define nurat_expt rb_rational_pow /* * call-seq: - * rational <=> numeric -> -1, 0, +1, or nil + * self <=> other -> -1, 0, 1, or nil + * + * Compares +self+ and +other+. + * + * Returns: * - * Returns -1, 0, or +1 depending on whether +rational+ is - * less than, equal to, or greater than +numeric+. + * - +-1+, if +self+ is less than +other+. + * - +0+, if the two values are the same. + * - +1+, if +self+ is greater than +other+. + * - +nil+, if the two values are incomparable. * - * +nil+ is returned if the two values are incomparable. + * Examples: * - * Rational(2, 3) <=> Rational(2, 3) #=> 0 - * Rational(5) <=> 5 #=> 0 - * Rational(2, 3) <=> Rational(1, 3) #=> 1 - * Rational(1, 3) <=> 1 #=> -1 - * Rational(1, 3) <=> 0.3 #=> 1 + * Rational(2, 3) <=> Rational(4, 3) # => -1 + * Rational(2, 1) <=> Rational(2, 1) # => 0 + * Rational(2, 1) <=> 2 # => 0 + * Rational(2, 1) <=> 2.0 # => 0 + * Rational(2, 1) <=> Complex(2, 0) # => 0 + * Rational(4, 3) <=> Rational(2, 3) # => 1 + * Rational(4, 3) <=> :foo # => nil + * + * \Class \Rational includes module Comparable, + * each of whose methods uses Rational#<=> for comparison. * - * Rational(1, 3) <=> "0.3" #=> nil */ VALUE rb_rational_cmp(VALUE self, VALUE other) @@ -1073,46 +1092,46 @@ 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, rb_intern("<=>")); + return rb_num_coerce_cmp(self, other, idCmp); } } /* * call-seq: - * rat == object -> true or false + * self == other -> true or false * - * Returns +true+ if +rat+ equals +object+ numerically. + * Returns whether +self+ and +other+ are numerically equal: * * Rational(2, 3) == Rational(2, 3) #=> true * Rational(5) == 5 #=> true @@ -1127,37 +1146,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); } } @@ -1166,17 +1185,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); @@ -1189,7 +1208,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; } @@ -1203,7 +1222,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)); } /* @@ -1216,7 +1235,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)); } /* @@ -1229,7 +1248,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 @@ -1276,7 +1294,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); } @@ -1292,14 +1310,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; } @@ -1316,7 +1334,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); @@ -1324,7 +1342,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; } @@ -1341,45 +1359,55 @@ 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; } +static VALUE f_round_n(VALUE self, VALUE n, VALUE (*func)(VALUE)) ; + static VALUE f_round_common(int argc, VALUE *argv, VALUE self, VALUE (*func)(VALUE)) { - VALUE n, b, s; + VALUE n; 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"); + + return f_round_n(self, n, func); +} + +static VALUE +f_round_n(VALUE self, VALUE n, VALUE (*func)(VALUE)) +{ + VALUE b, s; 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); @@ -1387,7 +1415,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; } @@ -1399,8 +1427,7 @@ rb_rational_floor(VALUE self, int ndigits) return nurat_floor(self); } else { - VALUE n = INT2NUM(ndigits); - return f_round_common(1, &n, self, nurat_floor); + return f_round_n(self, INT2NUM(ndigits), nurat_floor); } } @@ -1537,11 +1564,30 @@ 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(VALUE num, int ndigits, enum ruby_num_rounding_mode mode) +{ + VALUE (*round_func)(VALUE) = ROUND_FUNC(mode, nurat_round); + return nurat_to_f(f_round_n(float_to_r(num), INT2NUM(ndigits), round_func)); +} + +VALUE +rb_flo_ceil_by_rational(VALUE num, int ndigits) +{ + return nurat_to_f(f_round_n(float_to_r(num), INT2NUM(ndigits), nurat_ceil)); +} + +VALUE +rb_flo_floor_by_rational(VALUE num, int ndigits) +{ + return nurat_to_f(f_round_n(float_to_r(num), INT2NUM(ndigits), nurat_floor)); +} + static double nurat_to_double(VALUE self) { @@ -1680,19 +1726,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); @@ -1720,7 +1766,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]); @@ -1732,7 +1778,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) { @@ -1838,7 +1884,7 @@ nurat_loader(VALUE self, VALUE a) nurat_canonicalize(&num, &den); RATIONAL_SET_NUM((VALUE)dat, num); RATIONAL_SET_DEN((VALUE)dat, den); - OBJ_FREEZE_RAW(self); + OBJ_FREEZE(self); return self; } @@ -1865,7 +1911,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); @@ -1878,8 +1924,6 @@ nurat_marshal_load(VALUE self, VALUE a) return self; } -/* --- */ - VALUE rb_rational_reciprocal(VALUE x) { @@ -2054,30 +2098,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. @@ -2093,8 +2113,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); } @@ -2113,40 +2133,14 @@ 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) - * - * Returns zero as a rational. - */ -static VALUE -nilclass_to_r(VALUE self) -{ - return rb_rational_new1(INT2FIX(0)); -} - -/* - * call-seq: - * nil.rationalize([eps]) -> (0/1) - * - * Returns zero as a rational. The optional argument +eps+ is always - * ignored. - */ -static VALUE -nilclass_rationalize(int argc, VALUE *argv, VALUE self) -{ - rb_check_arity(argc, 0, 1); - return nilclass_to_r(self); -} - -/* - * call-seq: * int.to_r -> rational * * Returns the value as a rational. @@ -2222,7 +2216,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 } @@ -2320,8 +2314,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; } @@ -2332,15 +2326,21 @@ islettere(int c) return (c == 'e' || c == 'E'); } +inline static int +isletterr(int c) +{ + return (c == 'r' || c == 'R'); +} + 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); } } @@ -2354,51 +2354,57 @@ 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; - } - - 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); + n = n == ZERO ? fp : rb_int_plus(rb_int_mul(*num, l), fp); + *num = n; + fn = SIZET2NUM(count); + } + ok = 1; + } + + if (!ok || *s >= end) { + /* failed or finish */ + } + else if (isletterr(**s)) { + (*s)++; + } + else if (*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); exp = negate_num(exp); - } + } *nexp = exp; - } + } } return ok; @@ -2408,7 +2414,7 @@ inline static const char * skip_ws(const char *s, const char *e) { while (s < e && isspace((unsigned char)*s)) - ++s; + ++s; return s; } @@ -2422,30 +2428,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) { @@ -2476,7 +2482,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); @@ -2505,31 +2511,32 @@ string_to_r_strict(VALUE self, int raise) /* * call-seq: - * str.to_r -> rational - * - * Returns the result of interpreting leading characters in +str+ - * as a rational. Leading whitespace and extraneous characters - * past the end of a valid number are ignored. - * Digit sequences can be separated by an underscore. - * If there is not a valid number at the start of +str+, - * zero is returned. This method never raises an exception. - * - * ' 2 '.to_r #=> (2/1) - * '300/2'.to_r #=> (150/1) - * '-9.2'.to_r #=> (-46/5) - * '-9.2e2'.to_r #=> (-920/1) - * '1_234_567'.to_r #=> (1234567/1) - * '21 June 09'.to_r #=> (21/1) - * '21/06/09'.to_r #=> (7/2) - * 'BWV 1079'.to_r #=> (0/1) - * - * NOTE: "0.3".to_r isn't the same as 0.3.to_r. The former is - * equivalent to "3/10".to_r, but the latter isn't so. + * str.to_r -> rational * - * "0.3".to_r == 3/10r #=> true - * 0.3.to_r == 3/10r #=> false + * Returns the result of interpreting leading characters in +self+ as a rational value: + * + * '123'.to_r # => (123/1) # Integer literal. + * '300/2'.to_r # => (150/1) # Rational literal. + * '-9.2'.to_r # => (-46/5) # Float literal. + * '-9.2e2'.to_r # => (-920/1) # Float literal. + * + * Ignores leading and trailing whitespace, and trailing non-numeric characters: + * + * ' 2 '.to_r # => (2/1) + * '21-Jun-09'.to_r # => (21/1) + * + * Returns \Rational zero if there are no leading numeric characters. + * + * 'BWV 1079'.to_r # => (0/1) * - * See also Kernel#Rational. + * NOTE: <tt>'0.3'.to_r</tt> is equivalent to <tt>3/10r</tt>, + * but is different from <tt>0.3.to_r</tt>: + * + * '0.3'.to_r # => (3/10) + * 3/10r # => (3/10) + * 0.3.to_r # => (5404319552844595/18014398509481984) + * + * Related: see {Converting to Non-String}[rdoc-ref:String@Converting+to+Non--5CString]. */ static VALUE string_to_r(VALUE self) @@ -2541,7 +2548,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; } @@ -2553,7 +2560,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; } @@ -2569,11 +2576,11 @@ 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; - rb_raise(rb_eTypeError, "can't convert nil into Rational"); + rb_cant_convert(Qnil, "Rational"); } if (RB_TYPE_P(a1, T_COMPLEX)) { @@ -2620,7 +2627,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)) { @@ -2629,11 +2636,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); @@ -2683,7 +2690,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) { @@ -2714,13 +2721,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) * @@ -2778,7 +2791,7 @@ Init_Rational(void) rb_define_method(rb_cRational, "*", rb_rational_mul, 1); rb_define_method(rb_cRational, "/", rb_rational_div, 1); rb_define_method(rb_cRational, "quo", rb_rational_div, 1); - rb_define_method(rb_cRational, "fdiv", nurat_fdiv, 1); + rb_define_method(rb_cRational, "fdiv", rb_rational_fdiv, 1); rb_define_method(rb_cRational, "**", nurat_expt, 1); rb_define_method(rb_cRational, "<=>", rb_rational_cmp, 1); @@ -2811,8 +2824,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); @@ -2821,14 +2832,9 @@ 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); - rb_define_method(rb_cNilClass, "to_r", nilclass_to_r, 0); - rb_define_method(rb_cNilClass, "rationalize", nilclass_rationalize, -1); rb_define_method(rb_cInteger, "to_r", integer_to_r, 0); rb_define_method(rb_cInteger, "rationalize", integer_rationalize, -1); rb_define_method(rb_cFloat, "to_r", float_to_r, 0); |