diff options
Diffstat (limited to 'rational.c')
| -rw-r--r-- | rational.c | 2738 |
1 files changed, 1474 insertions, 1264 deletions
diff --git a/rational.c b/rational.c index 53bc11c4ef..b031838d69 100644 --- a/rational.c +++ b/rational.c @@ -5,21 +5,42 @@ which is written in ruby. */ -#include "ruby.h" -#include "internal.h" -#include <math.h> +#include "ruby/internal/config.h" + +#include <ctype.h> #include <float.h> +#include <math.h> #ifdef HAVE_IEEEFP_H #include <ieeefp.h> #endif -#define NDEBUG -#include <assert.h> - +#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 + +#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) @@ -28,250 +49,193 @@ #define GMP_GCD_DIGITS 1 +#define INT_ZERO_P(x) (FIXNUM_P(x) ? FIXNUM_ZERO_P(x) : rb_bigzero_p(x)) + VALUE rb_cRational; -static ID id_abs, id_cmp, id_convert, id_eqeq_p, id_expt, id_fdiv, - id_floor, id_idiv, id_integer_p, id_negate, id_to_f, - id_to_i, id_truncate, id_i_num, id_i_den; +static ID id_abs, id_integer_p, + id_i_num, id_i_den; + +#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 -#define binop(n,op) \ -inline static VALUE \ -f_##n(VALUE x, VALUE y)\ -{\ - return rb_funcall(x, (op), 1, y);\ -} - -#define fun1(n) \ -inline static VALUE \ -f_##n(VALUE x)\ -{\ - return rb_funcall(x, id_##n, 0);\ -} - -#define fun2(n) \ -inline static VALUE \ -f_##n(VALUE x, VALUE y)\ -{\ - return rb_funcall(x, id_##n, 1, y);\ -} +static VALUE nurat_to_f(VALUE self); +static VALUE float_to_r(VALUE self); inline static VALUE f_add(VALUE x, VALUE y) { - if (FIXNUM_P(y) && FIX2LONG(y) == 0) - return x; - else if (FIXNUM_P(x) && FIX2LONG(x) == 0) - return y; + if (FIXNUM_ZERO_P(y)) + return x; + if (FIXNUM_ZERO_P(x)) + return y; + if (RB_INTEGER_TYPE_P(x)) + return rb_int_plus(x, y); return rb_funcall(x, '+', 1, y); } inline static VALUE -f_cmp(VALUE x, VALUE y) -{ - if (FIXNUM_P(x) && FIXNUM_P(y)) { - long c = FIX2LONG(x) - FIX2LONG(y); - if (c > 0) - c = 1; - else if (c < 0) - c = -1; - return INT2FIX(c); - } - return rb_funcall(x, id_cmp, 1, y); -} - -inline static VALUE f_div(VALUE x, VALUE y) { - if (FIXNUM_P(y) && FIX2LONG(y) == 1) - return x; + if (y == ONE) + return x; + if (RB_INTEGER_TYPE_P(x)) + return rb_int_div(x, y); return rb_funcall(x, '/', 1, y); } -inline static VALUE -f_gt_p(VALUE x, VALUE y) +inline static int +f_lt_p(VALUE x, VALUE y) { if (FIXNUM_P(x) && FIXNUM_P(y)) - return f_boolcast(FIX2LONG(x) > FIX2LONG(y)); - return rb_funcall(x, '>', 1, 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); + } + return RTEST(rb_funcall(x, '<', 1, y)); } +#ifndef NDEBUG +/* f_mod is used only in f_gcd defined when NDEBUG is not defined */ inline static VALUE -f_lt_p(VALUE x, VALUE y) +f_mod(VALUE x, VALUE y) { - if (FIXNUM_P(x) && FIXNUM_P(y)) - return f_boolcast(FIX2LONG(x) < FIX2LONG(y)); - return rb_funcall(x, '<', 1, y); + if (RB_INTEGER_TYPE_P(x)) + return rb_int_modulo(x, y); + return rb_funcall(x, '%', 1, y); } - -binop(mod, '%') +#endif inline static VALUE f_mul(VALUE x, VALUE y) { - if (FIXNUM_P(y)) { - long iy = FIX2LONG(y); - if (iy == 0) { - if (FIXNUM_P(x) || RB_TYPE_P(x, T_BIGNUM)) - return ZERO; - } - else if (iy == 1) - return x; - } - else if (FIXNUM_P(x)) { - long ix = FIX2LONG(x); - if (ix == 0) { - if (FIXNUM_P(y) || RB_TYPE_P(y, T_BIGNUM)) - return ZERO; - } - else if (ix == 1) - return y; - } + if (FIXNUM_ZERO_P(y) && RB_INTEGER_TYPE_P(x)) + return ZERO; + if (y == ONE) return x; + if (FIXNUM_ZERO_P(x) && RB_INTEGER_TYPE_P(y)) + return ZERO; + if (x == ONE) return y; + else if (RB_INTEGER_TYPE_P(x)) + return rb_int_mul(x, y); return rb_funcall(x, '*', 1, y); } inline static VALUE f_sub(VALUE x, VALUE y) { - if (FIXNUM_P(y) && FIX2LONG(y) == 0) - return x; + if (FIXNUM_P(y) && FIXNUM_ZERO_P(y)) + return x; return rb_funcall(x, '-', 1, y); } -fun1(abs) -fun1(floor) -fun1(integer_p) -fun1(negate) - -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_funcall(x, id_to_i, 0); -} inline static VALUE -f_to_f(VALUE x) +f_abs(VALUE x) { - if (RB_TYPE_P(x, T_STRING)) - return DBL2NUM(rb_str_to_dbl(x, 0)); - return rb_funcall(x, id_to_f, 0); + if (RB_INTEGER_TYPE_P(x)) + return rb_int_abs(x); + return rb_funcall(x, id_abs, 0); } -fun1(truncate) -inline static VALUE -f_eqeq_p(VALUE x, VALUE y) +inline static int +f_integer_p(VALUE x) { - if (FIXNUM_P(x) && FIXNUM_P(y)) - return f_boolcast(FIX2LONG(x) == FIX2LONG(y)); - return rb_funcall(x, id_eqeq_p, 1, y); + return RB_INTEGER_TYPE_P(x); } -fun2(expt) -fun2(fdiv) -fun2(idiv) - -#define f_expt10(x) f_expt(INT2FIX(10), x) - inline static VALUE -f_negative_p(VALUE x) +f_to_i(VALUE x) { - if (FIXNUM_P(x)) - return f_boolcast(FIX2LONG(x) < 0); - return rb_funcall(x, '<', 1, ZERO); + if (RB_TYPE_P(x, T_STRING)) + return rb_str_to_inum(x, 10, 0); + return rb_funcall(x, id_to_i, 0); } -#define f_positive_p(x) (!f_negative_p(x)) +inline static int +f_eqeq_p(VALUE x, VALUE y) +{ + if (FIXNUM_P(x) && FIXNUM_P(y)) + return x == y; + if (RB_INTEGER_TYPE_P(x)) + return RTEST(rb_int_equal(x, y)); + return (int)rb_equal(x, y); +} inline static VALUE -f_zero_p(VALUE x) +f_idiv(VALUE x, VALUE y) { - if (RB_TYPE_P(x, T_FIXNUM)) { - return f_boolcast(FIX2LONG(x) == 0); - } - else if (RB_TYPE_P(x, T_BIGNUM)) { - return Qfalse; - } - else if (RB_TYPE_P(x, T_RATIONAL)) { - VALUE num = RRATIONAL(x)->num; - - return f_boolcast(FIXNUM_P(num) && FIX2LONG(num) == 0); - } - return rb_funcall(x, id_eqeq_p, 1, ZERO); + if (RB_INTEGER_TYPE_P(x)) + return rb_int_idiv(x, y); + return rb_funcall(x, id_idiv, 1, y); } -#define f_nonzero_p(x) (!f_zero_p(x)) +#define f_expt10(x) rb_int_pow(INT2FIX(10), x) -inline static VALUE +inline static int f_one_p(VALUE x) { - if (RB_TYPE_P(x, T_FIXNUM)) { - return f_boolcast(FIX2LONG(x) == 1); - } - else if (RB_TYPE_P(x, T_BIGNUM)) { - return Qfalse; + if (RB_INTEGER_TYPE_P(x)) { + 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 f_boolcast(FIXNUM_P(num) && FIX2LONG(num) == 1 && - FIXNUM_P(den) && FIX2LONG(den) == 1); + return num == LONG2FIX(1) && den == LONG2FIX(1); } - return rb_funcall(x, id_eqeq_p, 1, ONE); + return (int)rb_equal(x, ONE); } -inline static VALUE +inline static int f_minus_one_p(VALUE x) { - if (RB_TYPE_P(x, T_FIXNUM)) { - return f_boolcast(FIX2LONG(x) == -1); + if (RB_INTEGER_TYPE_P(x)) { + 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 f_boolcast(FIXNUM_P(num) && FIX2LONG(num) == -1 && - FIXNUM_P(den) && FIX2LONG(den) == 1); + return num == LONG2FIX(-1) && den == LONG2FIX(1); } - return rb_funcall(x, id_eqeq_p, 1, INT2FIX(-1)); + return (int)rb_equal(x, INT2FIX(-1)); } -inline static VALUE +inline static int f_kind_of_p(VALUE x, VALUE c) { - return rb_obj_is_kind_of(x, c); + return (int)rb_obj_is_kind_of(x, c); } -inline static VALUE +inline static int k_numeric_p(VALUE x) { return f_kind_of_p(x, rb_cNumeric); } -inline static VALUE +inline static int k_integer_p(VALUE x) { - return f_kind_of_p(x, rb_cInteger); + return RB_INTEGER_TYPE_P(x); } -inline static VALUE +inline static int k_float_p(VALUE x) { - return f_kind_of_p(x, rb_cFloat); + return RB_FLOAT_TYPE_P(x); } -inline static VALUE +inline static int k_rational_p(VALUE x) { - return f_kind_of_p(x, rb_cRational); + return RB_TYPE_P(x, T_RATIONAL); } #define k_exact_p(x) (!k_float_p(x)) @@ -280,11 +244,11 @@ 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) { - const size_t nails = (sizeof(BDIGIT)-SIZEOF_BDIGITS)*CHAR_BIT; + const size_t nails = (sizeof(BDIGIT)-SIZEOF_BDIGIT)*CHAR_BIT; mpz_t mx, my, mz; size_t count; VALUE z; @@ -293,14 +257,19 @@ rb_gcd_gmp(VALUE x, VALUE y) mpz_init(mx); mpz_init(my); mpz_init(mz); - mpz_import(mx, RBIGNUM_LEN(x), -1, sizeof(BDIGIT), 0, nails, RBIGNUM_DIGITS(x)); - mpz_import(my, RBIGNUM_LEN(y), -1, sizeof(BDIGIT), 0, nails, RBIGNUM_DIGITS(y)); + mpz_import(mx, BIGNUM_LEN(x), -1, sizeof(BDIGIT), 0, nails, BIGNUM_DIGITS(x)); + mpz_import(my, BIGNUM_LEN(y), -1, sizeof(BDIGIT), 0, nails, BIGNUM_DIGITS(y)); mpz_gcd(mz, mx, my); - zn = (mpz_sizeinbase(mz, 16) + SIZEOF_BDIGITS*2 - 1) / (SIZEOF_BDIGITS*2); + mpz_clear(mx); + mpz_clear(my); + + zn = (mpz_sizeinbase(mz, 16) + SIZEOF_BDIGIT*2 - 1) / (SIZEOF_BDIGIT*2); z = rb_big_new(zn, 1); - mpz_export(RBIGNUM_DIGITS(z), &count, -1, sizeof(BDIGIT), 0, nails, mz); + mpz_export(BIGNUM_DIGITS(z), &count, -1, sizeof(BDIGIT), 0, nails, mz); + + mpz_clear(mz); return rb_big_norm(z); } @@ -313,22 +282,42 @@ rb_gcd_gmp(VALUE x, VALUE y) inline static long i_gcd(long x, long y) { + unsigned long u, v, t; + 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; - while (x > 0) { - long t = x; - x = y % x; - y = t; + u = (unsigned long)x; + v = (unsigned long)y; + for (shift = 0; ((u | v) & 1) == 0; ++shift) { + u >>= 1; + v >>= 1; } - return y; + + while ((u & 1) == 0) + u >>= 1; + + do { + 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); } inline static VALUE @@ -337,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 (f_negative_p(x)) - x = f_negate(x); - if (f_negative_p(y)) - y = f_negate(y); + if (INT_NEGATIVE_P(x)) + x = rb_int_uminus(x); + if (INT_NEGATIVE_P(y)) + y = rb_int_uminus(y); - if (f_zero_p(x)) - return y; - if (f_zero_p(y)) - return x; + if (INT_ZERO_P(x)) + return y; + if (INT_ZERO_P(y)) + return x; for (;;) { - if (FIXNUM_P(x)) { - if (FIX2LONG(x) == 0) - return y; - if (FIXNUM_P(y)) - return LONG2NUM(i_gcd(FIX2LONG(x), FIX2LONG(y))); - } - z = x; - x = f_mod(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 */ } @@ -372,10 +361,10 @@ 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)) { - long xn = RBIGNUM_LEN(x); - long yn = RBIGNUM_LEN(y); +#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) return rb_gcd_gmp(x, y); } @@ -391,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; } @@ -401,27 +390,25 @@ f_gcd(VALUE x, VALUE y) inline static VALUE f_lcm(VALUE x, VALUE y) { - if (f_zero_p(x) || f_zero_p(y)) - return ZERO; + if (INT_ZERO_P(x) || INT_ZERO_P(y)) + return ZERO; return f_abs(f_mul(f_div(x, f_gcd(x, y)), y)); } #define get_dat1(x) \ - struct RRational *dat;\ - dat = ((struct RRational *)(x)) + struct RRational *dat = RRATIONAL(x) #define get_dat2(x,y) \ - struct RRational *adat, *bdat;\ - adat = ((struct RRational *)(x));\ - bdat = ((struct RRational *)(y)) + struct RRational *adat = RRATIONAL(x), *bdat = RRATIONAL(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)); - RRATIONAL_SET_NUM(obj, num); - RRATIONAL_SET_DEN(obj, den); + RATIONAL_SET_NUM((VALUE)obj, num); + RATIONAL_SET_DEN((VALUE)obj, den); + OBJ_FREEZE((VALUE)obj); return (VALUE)obj; } @@ -432,76 +419,18 @@ nurat_s_alloc(VALUE klass) return nurat_s_new_internal(klass, ZERO, ONE); } -#define rb_raise_zerodiv() rb_raise(rb_eZeroDivError, "divided by 0") - -#if 0 -static VALUE -nurat_s_new_bang(int argc, VALUE *argv, VALUE klass) -{ - VALUE num, den; - - switch (rb_scan_args(argc, argv, "11", &num, &den)) { - case 1: - if (!k_integer_p(num)) - num = f_to_i(num); - den = ONE; - break; - default: - if (!k_integer_p(num)) - num = f_to_i(num); - if (!k_integer_p(den)) - den = f_to_i(den); - - switch (FIX2INT(f_cmp(den, ZERO))) { - case -1: - num = f_negate(num); - den = f_negate(den); - break; - case 0: - rb_raise_zerodiv(); - break; - } - break; - } - - return nurat_s_new_internal(klass, num, den); -} -#endif - inline static VALUE f_rational_new_bang1(VALUE klass, VALUE x) { return nurat_s_new_internal(klass, x, ONE); } -inline static VALUE -f_rational_new_bang2(VALUE klass, VALUE x, VALUE y) -{ - assert(f_positive_p(y)); - assert(f_nonzero_p(y)); - return nurat_s_new_internal(klass, x, y); -} - -#ifdef CANONICALIZATION_FOR_MATHN -#define CANON -#endif - -#ifdef CANON -static int canonicalization = 0; - -RUBY_FUNC_EXPORTED void -nurat_canonicalization(int f) -{ - canonicalization = f; -} -#endif - inline static void nurat_int_check(VALUE num) { - if (!(RB_TYPE_P(num, T_FIXNUM) || RB_TYPE_P(num, T_BIGNUM))) { - if (!k_numeric_p(num) || !f_integer_p(num)) - rb_raise(rb_eTypeError, "not an integer"); + if (!RB_INTEGER_TYPE_P(num)) { + if (!k_numeric_p(num) || !f_integer_p(num)) + rb_raise(rb_eTypeError, "not an integer"); } } @@ -510,115 +439,92 @@ 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; } -inline static VALUE -nurat_s_canonicalize_internal(VALUE klass, VALUE num, VALUE den) +static void +nurat_canonicalize(VALUE *num, VALUE *den) { - VALUE gcd; - - switch (FIX2INT(f_cmp(den, ZERO))) { - case -1: - num = f_negate(num); - den = f_negate(den); - break; - case 0: - rb_raise_zerodiv(); - break; + 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); + } + else if (INT_ZERO_P(*den)) { + rb_num_zerodiv(); } - - gcd = f_gcd(num, den); - num = f_idiv(num, gcd); - den = f_idiv(den, gcd); - -#ifdef CANON - if (f_one_p(den) && canonicalization) - return num; -#endif - return nurat_s_new_internal(klass, num, den); } -inline static VALUE -nurat_s_canonicalize_internal_no_reduce(VALUE klass, VALUE num, VALUE den) +static void +nurat_reduce(VALUE *x, VALUE *y) { - switch (FIX2INT(f_cmp(den, ZERO))) { - case -1: - num = f_negate(num); - den = f_negate(den); - break; - case 0: - rb_raise_zerodiv(); - break; - } - -#ifdef CANON - if (f_one_p(den) && canonicalization) - return num; -#endif - return nurat_s_new_internal(klass, num, den); + VALUE gcd; + if (*x == ONE || *y == ONE) return; + gcd = f_gcd(*x, *y); + *x = f_idiv(*x, gcd); + *y = f_idiv(*y, gcd); } -static VALUE -nurat_s_new(int argc, VALUE *argv, VALUE klass) +inline static VALUE +nurat_s_canonicalize_internal(VALUE klass, VALUE num, VALUE den) { - VALUE num, den; - - switch (rb_scan_args(argc, argv, "11", &num, &den)) { - case 1: - num = nurat_int_value(num); - den = ONE; - break; - default: - num = nurat_int_value(num); - den = nurat_int_value(den); - break; - } + nurat_canonicalize(&num, &den); + nurat_reduce(&num, &den); - return nurat_s_canonicalize_internal(klass, num, den); + return nurat_s_new_internal(klass, num, den); } inline static VALUE -f_rational_new1(VALUE klass, VALUE x) +nurat_s_canonicalize_internal_no_reduce(VALUE klass, VALUE num, VALUE den) { - assert(!k_rational_p(x)); - return nurat_s_canonicalize_internal(klass, x, ONE); + nurat_canonicalize(&num, &den); + + return nurat_s_new_internal(klass, num, 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_reduce1(VALUE klass, VALUE x) -{ - assert(!k_rational_p(x)); - return nurat_s_canonicalize_internal_no_reduce(klass, x, ONE); -} - -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); } +static VALUE nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise); +static VALUE nurat_s_convert(int argc, VALUE *argv, VALUE klass); + /* * call-seq: - * Rational(x[, y]) -> numeric + * Rational(x, y, exception: true) -> rational or nil + * Rational(arg, exception: true) -> rational or nil + * + * Returns +x/y+ or +arg+ as a Rational. + * + * Rational(2, 3) #=> (2/3) + * Rational(5) #=> (5/1) + * Rational(0.5) #=> (1/2) + * Rational(0.3) #=> (5404319552844595/18014398509481984) + * + * Rational("2/3") #=> (2/3) + * Rational("0.3") #=> (3/10) * - * Returns x/y; + * Rational("10 cents") #=> ArgumentError + * Rational(nil) #=> TypeError + * Rational(1, nil) #=> TypeError * - * Rational(1, 2) #=> (1/2) - * Rational('1/2') #=> (1/2) + * Rational("10 cents", exception: false) #=> nil * - * Syntax of string form: + * Syntax of the string form: * * string form = extra spaces , rational , extra spaces ; * rational = [ sign ] , unsigned rational ; @@ -632,12 +538,21 @@ f_rational_new_no_reduce2(VALUE klass, VALUE x, VALUE y) * digit = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ; * extra spaces = ? \s* ? ; * - * See String#to_r. + * See also String#to_r. */ static VALUE nurat_f_rational(int argc, VALUE *argv, VALUE klass) { - return rb_funcall2(rb_cRational, id_convert, argc, argv); + VALUE a1, a2, opts = Qnil; + int raise = TRUE; + + if (rb_scan_args(argc, argv, "11:", &a1, &a2, &opts) == 1) { + a2 = Qundef; + } + if (!NIL_P(opts)) { + raise = rb_opts_exception_p(opts, raise); + } + return nurat_convert(rb_cRational, a1, a2, raise); } /* @@ -668,7 +583,6 @@ nurat_numerator(VALUE self) * Rational(7, 1).denominator #=> 1 * Rational(9, -4).denominator #=> 4 * Rational(-2, -10).denominator #=> 5 - * rat.numerator.gcd(rat.denominator) #=> 1 */ static VALUE nurat_denominator(VALUE self) @@ -677,6 +591,25 @@ nurat_denominator(VALUE self) return dat->den; } +/* + * call-seq: + * -self -> rational + * + * Returns +self+, negated: + * + * -(1/3r) # => (-1/3) + * -(-1/3r) # => (1/3) + * + */ +VALUE +rb_rational_uminus(VALUE self) +{ + 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); +} + #ifndef NDEBUG #define f_imul f_imul_orig #endif @@ -687,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; @@ -707,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 @@ -718,128 +651,147 @@ 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 = f_add(a, b); - else - c = f_sub(a, b); - - b = f_idiv(aden, g); - g = f_gcd(c, g); - num = f_idiv(c, g); - a = f_idiv(bden, g); - den = f_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); } else { - VALUE g = f_gcd(aden, bden); - VALUE a = f_mul(anum, f_idiv(bden, g)); - VALUE b = f_mul(bnum, f_idiv(aden, g)); - VALUE c; - - if (k == '+') - c = f_add(a, b); - else - c = f_sub(a, b); - - b = f_idiv(aden, g); - g = f_gcd(c, g); - num = f_idiv(c, g); - a = f_idiv(bden, g); - den = f_mul(a, b); + double a = NUM2DBL(anum) / NUM2DBL(aden); + double b = NUM2DBL(bnum) / NUM2DBL(bden); + double c = k == '+' ? a + b : a - b; + return DBL2NUM(c); } return f_rational_new_no_reduce2(CLASS_OF(self), num, den); } +static double nurat_to_double(VALUE self); /* - * call-seq: - * rat + numeric -> numeric + * call-seq: + * self + other -> numeric + * + * 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) * - * Performs addition. + * 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) #=> (900/1) - * Rational(-2, 9) + Rational(-9, 2) #=> (-85/18) - * Rational(9, 8) + 4 #=> (41/8) - * Rational(20, 9) + 9.8 #=> 12.022222222222222 */ -static VALUE -nurat_add(VALUE self, VALUE other) +VALUE +rb_rational_plus(VALUE self, VALUE other) { - if (RB_TYPE_P(other, T_FIXNUM) || RB_TYPE_P(other, T_BIGNUM)) { - { - get_dat1(self); + if (RB_INTEGER_TYPE_P(other)) { + { + get_dat1(self); - return f_addsub(self, - dat->num, dat->den, - other, ONE, '+'); - } + 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_TYPE_P(other, T_FLOAT)) { - return f_add(f_to_f(self), other); + else if (RB_FLOAT_TYPE_P(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) * Rational(-2, 9) - Rational(-9, 2) #=> (77/18) - * Rational(9, 8) - 4 #=> (23/8) + * Rational(9, 8) - 4 #=> (-23/8) * Rational(20, 9) - 9.8 #=> -7.577777777777778 */ -static VALUE -nurat_sub(VALUE self, VALUE other) +VALUE +rb_rational_minus(VALUE self, VALUE other) { - if (RB_TYPE_P(other, T_FIXNUM) || RB_TYPE_P(other, T_BIGNUM)) { - { - get_dat1(self); + if (RB_INTEGER_TYPE_P(other)) { + { + get_dat1(self); - return f_addsub(self, - dat->num, dat->den, - other, ONE, '-'); - } + 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_TYPE_P(other, T_FLOAT)) { - return f_sub(f_to_f(self), other); + else if (RB_FLOAT_TYPE_P(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, '-'); } } @@ -848,87 +800,104 @@ f_muldiv(VALUE self, VALUE anum, VALUE aden, VALUE bnum, VALUE bden, int k) { VALUE num, den; + 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) || + RB_FLOAT_TYPE_P(bnum) || RB_FLOAT_TYPE_P(bden)) { + double an = NUM2DBL(anum), ad = NUM2DBL(aden); + double bn = NUM2DBL(bnum), bd = NUM2DBL(bden); + double x = (an * bn) / (ad * bd); + return DBL2NUM(x); + } + + 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 (f_negative_p(bnum)) { - anum = f_negate(anum); - bnum = f_negate(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 = f_mul(f_idiv(anum, g1), f_idiv(bnum, g2)); - den = f_mul(f_idiv(aden, g2), f_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 + * + * Returns the numeric product of +self+ and +other+: * - * Performs multiplication. + * 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 */ -static VALUE -nurat_mul(VALUE self, VALUE other) +VALUE +rb_rational_mul(VALUE self, VALUE other) { - if (RB_TYPE_P(other, T_FIXNUM) || RB_TYPE_P(other, T_BIGNUM)) { - { - get_dat1(self); + if (RB_INTEGER_TYPE_P(other)) { + { + 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_TYPE_P(other, T_FLOAT)) { - return f_mul(f_to_f(self), other); + else if (RB_FLOAT_TYPE_P(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) @@ -936,39 +905,41 @@ nurat_mul(VALUE self, VALUE other) * Rational(9, 8) / 4 #=> (9/32) * Rational(20, 9) / 9.8 #=> 0.22675736961451246 */ -static VALUE -nurat_div(VALUE self, VALUE other) +VALUE +rb_rational_div(VALUE self, VALUE other) { - if (RB_TYPE_P(other, T_FIXNUM) || RB_TYPE_P(other, T_BIGNUM)) { - if (f_zero_p(other)) - rb_raise_zerodiv(); - { - get_dat1(self); + if (RB_INTEGER_TYPE_P(other)) { + if (f_zero_p(other)) + rb_num_zerodiv(); + { + 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_FLOAT)) - return rb_funcall(f_to_f(self), '/', 1, other); else if (RB_TYPE_P(other, T_RATIONAL)) { - if (f_zero_p(other)) - rb_raise_zerodiv(); - { - get_dat2(self, other); + if (f_zero_p(other)) + rb_num_zerodiv(); + { + 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, '/'); } } @@ -976,169 +947,191 @@ nurat_div(VALUE self, VALUE other) * call-seq: * rat.fdiv(numeric) -> float * - * Performs division and returns the value as a float. + * Performs division and returns the value as a Float. * * Rational(2, 3).fdiv(1) #=> 0.6666666666666666 * 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 f_div(self, f_to_f(other)); - return f_to_f(f_div(self, other)); -} - -inline static VALUE -f_odd_p(VALUE integer) -{ - if (rb_funcall(integer, '%', 1, INT2FIX(2)) != INT2FIX(0)) { - return Qtrue; - } - return Qfalse; + return rb_rational_div(self, rb_float_new(0.0)); + if (FIXNUM_P(other) && other == LONG2FIX(1)) + return nurat_to_f(self); + div = rb_rational_div(self, other); + if (RB_TYPE_P(div, T_RATIONAL)) + return nurat_to_f(div); + if (RB_FLOAT_TYPE_P(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) - * Rational(10) ** -2.0 #=> 0.01 - * Rational(-4) ** Rational(1,2) #=> (1.2246063538223773e-16+2.0i) - * Rational(1, 2) ** 0 #=> (1/1) - * Rational(1, 2) ** 0.0 #=> 1.0 + * Rational(2) ** Rational(3) #=> (8/1) + * Rational(10) ** -2 #=> (1/100) + * Rational(10) ** -2.0 #=> 0.01 + * Rational(-4) ** Rational(1, 2) #=> (0.0+2.0i) + * Rational(1, 2) ** 0 #=> (1/1) + * Rational(1, 2) ** 0.0 #=> 1.0 */ -static VALUE -nurat_expt(VALUE self, VALUE other) +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) && k_integer_p(other)) { - return f_rational_new_bang1(CLASS_OF(self), INT2FIX(f_odd_p(other) ? -1 : 1)); - } - else if (f_zero_p(dat->num)) { - if (FIX2INT(f_cmp(other, ZERO)) == -1) { - rb_raise_zerodiv(); - } - else { - return f_rational_new_bang1(CLASS_OF(self), ZERO); - } - } - } + 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); + } + } + } } /* General case */ - if (RB_TYPE_P(other, T_FIXNUM)) { - { - VALUE num, den; - - get_dat1(self); - - switch (FIX2INT(f_cmp(other, ZERO))) { - case 1: - num = f_expt(dat->num, other); - den = f_expt(dat->den, other); - break; - case -1: - num = f_expt(dat->den, f_negate(other)); - den = f_expt(dat->num, f_negate(other)); - break; - default: - num = ONE; - den = ONE; - break; - } - 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 f_expt(f_to_f(self), other); - } - else if (RB_TYPE_P(other, T_FLOAT) || RB_TYPE_P(other, T_RATIONAL)) { - return f_expt(f_to_f(self), other); + if (FIXNUM_P(other)) { + { + VALUE num, den; + + get_dat1(self); + + if (INT_POSITIVE_P(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)); + } + 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_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); } else { - return rb_num_coerce_bin(self, other, id_expt); + 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: * - * Performs comparison and returns -1, 0, or +1. + * - +-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(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(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 */ -static VALUE -nurat_cmp(VALUE self, VALUE other) -{ - if (RB_TYPE_P(other, T_FIXNUM) || RB_TYPE_P(other, T_BIGNUM)) { - { - get_dat1(self); +VALUE +rb_rational_cmp(VALUE self, VALUE other) +{ + switch (TYPE(other)) { + case T_FIXNUM: + case T_BIGNUM: + { + 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); + /* 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); + } + + case T_FLOAT: + return rb_dbl_cmp(nurat_to_double(self), RFLOAT_VALUE(other)); - if (FIXNUM_P(dat->den) && FIX2LONG(dat->den) == 1) - return f_cmp(dat->num, other); /* c14n */ - return f_cmp(self, f_rational_new_bang1(CLASS_OF(self), other)); - } - } - else if (RB_TYPE_P(other, T_FLOAT)) { - return f_cmp(f_to_f(self), other); - } - else if (RB_TYPE_P(other, 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 = f_mul(adat->num, bdat->den); - num2 = f_mul(bdat->num, adat->den); - } - return f_cmp(f_sub(num1, num2), ZERO); - } - } - else { - return rb_num_coerce_cmp(self, other, id_cmp); + default: + 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 @@ -1149,38 +1142,41 @@ nurat_cmp(VALUE self, VALUE other) static VALUE nurat_eqeq_p(VALUE self, VALUE other) { - if (RB_TYPE_P(other, T_FIXNUM) || RB_TYPE_P(other, T_BIGNUM)) { - { - get_dat1(self); + if (RB_INTEGER_TYPE_P(other)) { + get_dat1(self); - if (f_zero_p(dat->num) && f_zero_p(other)) - return Qtrue; + 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; - if (f_eqeq_p(dat->num, other)) - return Qtrue; - return Qfalse; - } + 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 RBOOL(FIXNUM_ZERO_P(rb_dbl_cmp(d, NUM2DBL(other)))); + } } - else if (RB_TYPE_P(other, T_FLOAT)) { - return f_eqeq_p(f_to_f(self), other); + else if (RB_FLOAT_TYPE_P(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 (f_zero_p(adat->num) && f_zero_p(bdat->num)) - return Qtrue; + if (INT_ZERO_P(adat->num) && INT_ZERO_P(bdat->num)) + return Qtrue; - return f_boolcast(f_eqeq_p(adat->num, bdat->num) && - f_eqeq_p(adat->den, bdat->den)); - } + return RBOOL(rb_int_equal(adat->num, bdat->num) && + rb_int_equal(adat->den, bdat->den)); + } } else { - return f_eqeq_p(other, self); + return rb_equal(other, self); } } @@ -1188,73 +1184,95 @@ nurat_eqeq_p(VALUE self, VALUE other) static VALUE nurat_coerce(VALUE self, VALUE other) { - if (RB_TYPE_P(other, T_FIXNUM) || RB_TYPE_P(other, T_BIGNUM)) { - return rb_assoc_new(f_rational_new_bang1(CLASS_OF(self), other), self); + if (RB_INTEGER_TYPE_P(other)) { + return rb_assoc_new(f_rational_new_bang1(CLASS_OF(self), other), self); } - else if (RB_TYPE_P(other, T_FLOAT)) { - return rb_assoc_new(other, f_to_f(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(f_rational_new_bang1 - (CLASS_OF(self), RCOMPLEX(other)->real), self); - else - 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); + RBASIC_SET_CLASS(other, CLASS_OF(self)); + } + else { + other = f_rational_new_bang1(CLASS_OF(self), other); + } + return rb_assoc_new(other, self); } 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; } -#if 0 -/* :nodoc: */ +/* + * call-seq: + * rat.positive? -> true or false + * + * Returns +true+ if +rat+ is greater than 0. + */ static VALUE -nurat_idiv(VALUE self, VALUE other) +nurat_positive_p(VALUE self) { - return f_idiv(self, other); + get_dat1(self); + return RBOOL(INT_POSITIVE_P(dat->num)); } -/* :nodoc: */ +/* + * call-seq: + * rat.negative? -> true or false + * + * Returns +true+ if +rat+ is less than 0. + */ static VALUE -nurat_quot(VALUE self, VALUE other) +nurat_negative_p(VALUE self) { - return f_truncate(f_div(self, other)); + get_dat1(self); + return RBOOL(INT_NEGATIVE_P(dat->num)); } -/* :nodoc: */ -static VALUE -nurat_quotrem(VALUE self, VALUE other) -{ - VALUE val = f_truncate(f_div(self, other)); - return rb_assoc_new(val, f_sub(self, f_mul(other, val))); -} -#endif +/* + * call-seq: + * rat.abs -> rational + * rat.magnitude -> rational + * + * Returns the absolute value of +rat+. + * + * (1/2r).abs #=> (1/2) + * (-1/2r).abs #=> (1/2) + * + */ -#if 0 -/* :nodoc: */ -static VALUE -nurat_true(VALUE self) +VALUE +rb_rational_abs(VALUE self) { - return Qtrue; + get_dat1(self); + if (INT_NEGATIVE_P(dat->num)) { + VALUE num = rb_int_abs(dat->num); + return nurat_s_canonicalize_internal_no_reduce(CLASS_OF(self), num, dat->den); + } + return self; } -#endif static VALUE nurat_floor(VALUE self) { get_dat1(self); - return f_idiv(dat->num, dat->den); + return rb_int_idiv(dat->num, dat->den); } static VALUE nurat_ceil(VALUE self) { get_dat1(self); - return f_negate(f_idiv(f_negate(dat->num), dat->den)); + return rb_int_uminus(rb_int_idiv(rb_int_uminus(dat->num), dat->den)); } /* @@ -1263,26 +1281,49 @@ nurat_ceil(VALUE self) * * Returns the truncated value as an integer. * - * Equivalent to - * rat.truncate. + * Equivalent to Rational#truncate. * - * Rational(2, 3).to_i #=> 0 - * Rational(3).to_i #=> 3 - * Rational(300.6).to_i #=> 300 - * Rational(98,71).to_i #=> 1 - * Rational(-30,2).to_i #=> -15 + * Rational(2, 3).to_i #=> 0 + * Rational(3).to_i #=> 3 + * Rational(300.6).to_i #=> 300 + * Rational(98, 71).to_i #=> 1 + * Rational(-31, 2).to_i #=> -15 */ static VALUE nurat_truncate(VALUE self) { get_dat1(self); - if (f_negative_p(dat->num)) - return f_negate(f_idiv(f_negate(dat->num), dat->den)); - return f_idiv(dat->num, dat->den); + if (INT_NEGATIVE_P(dat->num)) + return rb_int_uminus(rb_int_idiv(rb_int_uminus(dat->num), dat->den)); + return rb_int_idiv(dat->num, dat->den); +} + +static VALUE +nurat_round_half_up(VALUE self) +{ + VALUE num, den, neg; + + get_dat1(self); + + num = dat->num; + den = dat->den; + neg = INT_NEGATIVE_P(num); + + if (neg) + 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); + + return num; } static VALUE -nurat_round(VALUE self) +nurat_round_half_down(VALUE self) { VALUE num, den, neg; @@ -1290,74 +1331,129 @@ nurat_round(VALUE self) num = dat->num; den = dat->den; - neg = f_negative_p(num); + neg = INT_NEGATIVE_P(num); if (neg) - num = f_negate(num); + num = rb_int_uminus(num); - num = f_add(f_mul(num, TWO), den); - den = f_mul(den, TWO); - num = f_idiv(num, den); + num = rb_int_plus(rb_int_mul(num, TWO), den); + num = rb_int_minus(num, ONE); + den = rb_int_mul(den, TWO); + num = rb_int_idiv(num, den); if (neg) - num = f_negate(num); + num = rb_int_uminus(num); return num; } static VALUE +nurat_round_half_even(VALUE self) +{ + VALUE num, den, neg, qr; + + get_dat1(self); + + num = dat->num; + den = dat->den; + neg = INT_NEGATIVE_P(num); + + if (neg) + 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))); + + if (neg) + 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 (argc == 0) - return (*func)(self); + if (rb_check_arity(argc, 0, 1) == 0) + return (*func)(self); - rb_scan_args(argc, argv, "01", &n); + 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 = f_mul(self, b); + s = rb_rational_mul(self, b); if (k_float_p(s)) { - if (f_lt_p(n, ZERO)) - 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); - s = f_div(f_rational_new_bang1(CLASS_OF(self), s), b); + s = rb_rational_div(f_rational_new_bang1(CLASS_OF(self), s), b); - if (f_lt_p(n, ONE)) - s = f_to_i(s); + if (RB_TYPE_P(s, T_RATIONAL) && FIX2INT(rb_int_cmp(n, ONE)) < 0) + s = nurat_truncate(s); return s; } +VALUE +rb_rational_floor(VALUE self, int ndigits) +{ + if (ndigits == 0) { + return nurat_floor(self); + } + else { + return f_round_n(self, INT2NUM(ndigits), nurat_floor); + } +} + /* * call-seq: - * rat.floor -> integer - * rat.floor(precision=0) -> rational + * rat.floor([ndigits]) -> integer or rational + * + * Returns the largest number less than or equal to +rat+ with + * a precision of +ndigits+ decimal digits (default: 0). + * + * When the precision is negative, the returned value is an integer + * with at least <code>ndigits.abs</code> trailing zeros. * - * Returns the truncated value (toward negative infinity). + * Returns a rational when +ndigits+ is positive, + * otherwise returns an integer. * * Rational(3).floor #=> 3 * Rational(2, 3).floor #=> 0 - * Rational(-3, 2).floor #=> -1 + * Rational(-3, 2).floor #=> -2 * - * decimal - 1 2 3 . 4 5 6 - * ^ ^ ^ ^ ^ ^ - * precision -3 -2 -1 0 +1 +2 + * # decimal - 1 2 3 . 4 5 6 + * # ^ ^ ^ ^ ^ ^ + * # precision -3 -2 -1 0 +1 +2 * - * '%f' % Rational('-123.456').floor(+1) #=> "-123.500000" - * '%f' % Rational('-123.456').floor(-1) #=> "-130.000000" + * Rational('-123.456').floor(+1).to_f #=> -123.5 + * Rational('-123.456').floor(-1) #=> -130 */ static VALUE nurat_floor_n(int argc, VALUE *argv, VALUE self) @@ -1367,21 +1463,27 @@ nurat_floor_n(int argc, VALUE *argv, VALUE self) /* * call-seq: - * rat.ceil -> integer - * rat.ceil(precision=0) -> rational + * rat.ceil([ndigits]) -> integer or rational * - * Returns the truncated value (toward positive infinity). + * Returns the smallest number greater than or equal to +rat+ with + * a precision of +ndigits+ decimal digits (default: 0). + * + * When the precision is negative, the returned value is an integer + * with at least <code>ndigits.abs</code> trailing zeros. + * + * Returns a rational when +ndigits+ is positive, + * otherwise returns an integer. * * Rational(3).ceil #=> 3 * Rational(2, 3).ceil #=> 1 * Rational(-3, 2).ceil #=> -1 * - * decimal - 1 2 3 . 4 5 6 - * ^ ^ ^ ^ ^ ^ - * precision -3 -2 -1 0 +1 +2 + * # decimal - 1 2 3 . 4 5 6 + * # ^ ^ ^ ^ ^ ^ + * # precision -3 -2 -1 0 +1 +2 * - * '%f' % Rational('-123.456').ceil(+1) #=> "-123.400000" - * '%f' % Rational('-123.456').ceil(-1) #=> "-120.000000" + * Rational('-123.456').ceil(+1).to_f #=> -123.4 + * Rational('-123.456').ceil(-1) #=> -120 */ static VALUE nurat_ceil_n(int argc, VALUE *argv, VALUE self) @@ -1391,21 +1493,27 @@ nurat_ceil_n(int argc, VALUE *argv, VALUE self) /* * call-seq: - * rat.truncate -> integer - * rat.truncate(precision=0) -> rational + * rat.truncate([ndigits]) -> integer or rational + * + * Returns +rat+ truncated (toward zero) to + * a precision of +ndigits+ decimal digits (default: 0). + * + * When the precision is negative, the returned value is an integer + * with at least <code>ndigits.abs</code> trailing zeros. * - * Returns the truncated value (toward zero). + * Returns a rational when +ndigits+ is positive, + * otherwise returns an integer. * * Rational(3).truncate #=> 3 * Rational(2, 3).truncate #=> 0 * Rational(-3, 2).truncate #=> -1 * - * decimal - 1 2 3 . 4 5 6 - * ^ ^ ^ ^ ^ ^ - * precision -3 -2 -1 0 +1 +2 + * # decimal - 1 2 3 . 4 5 6 + * # ^ ^ ^ ^ ^ ^ + * # precision -3 -2 -1 0 +1 +2 * - * '%f' % Rational('-123.456').truncate(+1) #=> "-123.400000" - * '%f' % Rational('-123.456').truncate(-1) #=> "-120.000000" + * Rational('-123.456').truncate(+1).to_f #=> -123.4 + * Rational('-123.456').truncate(-1) #=> -120 */ static VALUE nurat_truncate_n(int argc, VALUE *argv, VALUE self) @@ -1415,34 +1523,86 @@ nurat_truncate_n(int argc, VALUE *argv, VALUE self) /* * call-seq: - * rat.round -> integer - * rat.round(precision=0) -> rational + * rat.round([ndigits] [, half: mode]) -> integer or rational * - * Returns the truncated value (toward the nearest integer; - * 0.5 => 1; -0.5 => -1). + * Returns +rat+ rounded to the nearest value with + * a precision of +ndigits+ decimal digits (default: 0). + * + * When the precision is negative, the returned value is an integer + * with at least <code>ndigits.abs</code> trailing zeros. + * + * Returns a rational when +ndigits+ is positive, + * otherwise returns an integer. * * Rational(3).round #=> 3 * Rational(2, 3).round #=> 1 * Rational(-3, 2).round #=> -2 * - * decimal - 1 2 3 . 4 5 6 - * ^ ^ ^ ^ ^ ^ - * precision -3 -2 -1 0 +1 +2 - * - * '%f' % Rational('-123.456').round(+1) #=> "-123.500000" - * '%f' % Rational('-123.456').round(-1) #=> "-120.000000" + * # decimal - 1 2 3 . 4 5 6 + * # ^ ^ ^ ^ ^ ^ + * # precision -3 -2 -1 0 +1 +2 + * + * Rational('-123.456').round(+1).to_f #=> -123.5 + * Rational('-123.456').round(-1) #=> -120 + * + * The optional +half+ keyword argument is available + * similar to Float#round. + * + * Rational(25, 100).round(1, half: :up) #=> (3/10) + * Rational(25, 100).round(1, half: :down) #=> (1/5) + * Rational(25, 100).round(1, half: :even) #=> (1/5) + * Rational(35, 100).round(1, half: :up) #=> (2/5) + * Rational(35, 100).round(1, half: :down) #=> (3/10) + * Rational(35, 100).round(1, half: :even) #=> (2/5) + * Rational(-25, 100).round(1, half: :up) #=> (-3/10) + * Rational(-25, 100).round(1, half: :down) #=> (-1/5) + * Rational(-25, 100).round(1, half: :even) #=> (-1/5) */ static VALUE nurat_round_n(int argc, VALUE *argv, VALUE self) { - return f_round_common(argc, argv, self, nurat_round); + VALUE opt; + enum ruby_num_rounding_mode mode = ( + argc = rb_scan_args(argc, argv, "*:", NULL, &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) +{ + get_dat1(self); + if (!RB_INTEGER_TYPE_P(dat->num) || !RB_INTEGER_TYPE_P(dat->den)) { + return NUM2DBL(dat->num) / NUM2DBL(dat->den); + } + return rb_int_fdiv_double(dat->num, dat->den); } /* * call-seq: * rat.to_f -> float * - * Return the value as a float. + * Returns the value as a Float. * * Rational(2).to_f #=> 2.0 * Rational(9, 4).to_f #=> 2.25 @@ -1452,8 +1612,7 @@ nurat_round_n(int argc, VALUE *argv, VALUE self) static VALUE nurat_to_f(VALUE self) { - get_dat1(self); - return f_fdiv(dat->num, dat->den); + return DBL2NUM(nurat_to_double(self)); } /* @@ -1472,10 +1631,28 @@ nurat_to_r(VALUE self) } #define id_ceil rb_intern("ceil") -#define f_ceil(x) rb_funcall((x), id_ceil, 0) +static VALUE +f_ceil(VALUE x) +{ + if (RB_INTEGER_TYPE_P(x)) + return x; + if (RB_FLOAT_TYPE_P(x)) + return rb_float_ceil(x, 0); + + return rb_funcall(x, id_ceil, 0); +} + +#define id_quo idQuo +static VALUE +f_quo(VALUE x, VALUE y) +{ + if (RB_INTEGER_TYPE_P(x)) + return rb_int_div(x, y); + if (RB_FLOAT_TYPE_P(x)) + return DBL2NUM(RFLOAT_VALUE(x) / RFLOAT_VALUE(y)); -#define id_quo rb_intern("quo") -#define f_quo(x,y) rb_funcall((x), id_quo, 1, (y)) + return rb_funcallv(x, id_quo, 1, &y); +} #define f_reciprocal(x) f_quo(ONE, (x)) @@ -1549,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); @@ -1573,8 +1750,8 @@ nurat_rationalize_internal(VALUE a, VALUE b, VALUE *p, VALUE *q) * rat.rationalize(eps) -> rational * * Returns a simpler approximation of the value if the optional - * argument eps is given (rat-|eps| <= result <= rat+|eps|), self - * otherwise. + * argument +eps+ is given (rat-|eps| <= result <= rat+|eps|), + * self otherwise. * * r = Rational(5033165, 16777216) * r.rationalize #=> (5033165/16777216) @@ -1585,28 +1762,36 @@ static VALUE nurat_rationalize(int argc, VALUE *argv, VALUE self) { VALUE e, a, b, p, q; + VALUE rat = self; + get_dat1(self); - if (argc == 0) - return self; + if (rb_check_arity(argc, 0, 1) == 0) + return self; - if (f_negative_p(self)) - return f_negate(nurat_rationalize(argc, argv, f_abs(self))); + e = f_abs(argv[0]); + + if (INT_NEGATIVE_P(dat->num)) { + rat = f_rational_new2(RBASIC_CLASS(self), rb_int_uminus(dat->num), dat->den); + } - rb_scan_args(argc, argv, "01", &e); - e = f_abs(e); - a = f_sub(self, e); - b = f_add(self, e); + a = FIXNUM_ZERO_P(e) ? rat : rb_rational_minus(rat, e); + 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) { + RATIONAL_SET_NUM(rat, rb_int_uminus(p)); + RATIONAL_SET_DEN(rat, q); + return rat; + } return f_rational_new2(CLASS_OF(self), p, q); } /* :nodoc: */ -static VALUE -nurat_hash(VALUE self) +st_index_t +rb_rational_hash(VALUE self) { st_index_t v, h[2]; VALUE n; @@ -1617,9 +1802,16 @@ nurat_hash(VALUE self) n = rb_hash(dat->den); h[1] = NUM2LONG(n); v = rb_memhash(h, sizeof(h)); - return LONG2FIX(v); + return v; +} + +static VALUE +nurat_hash(VALUE self) +{ + return ST2FIX(rb_rational_hash(self)); } + static VALUE f_format(VALUE self, VALUE (*func)(VALUE)) { @@ -1682,10 +1874,17 @@ nurat_dumper(VALUE self) static VALUE nurat_loader(VALUE self, VALUE a) { - get_dat1(self); + VALUE num, den; - RRATIONAL_SET_NUM(dat, rb_ivar_get(a, id_i_num)); - RRATIONAL_SET_DEN(dat, rb_ivar_get(a, id_i_den)); + get_dat1(self); + num = rb_ivar_get(a, id_i_num); + den = rb_ivar_get(a, id_i_den); + nurat_int_check(num); + nurat_int_check(den); + nurat_canonicalize(&num, &den); + RATIONAL_SET_NUM((VALUE)dat, num); + RATIONAL_SET_DEN((VALUE)dat, den); + OBJ_FREEZE(self); return self; } @@ -1706,37 +1905,40 @@ nurat_marshal_dump(VALUE self) static VALUE nurat_marshal_load(VALUE self, VALUE a) { + VALUE num, den; + rb_check_frozen(self); - rb_check_trusted(self); 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)); - if (f_zero_p(RARRAY_AREF(a, 1))) - rb_raise_zerodiv(); + rb_raise(rb_eArgError, "marshaled rational must have an array whose length is 2 but %ld", RARRAY_LEN(a)); - rb_ivar_set(self, id_i_num, RARRAY_AREF(a, 0)); - rb_ivar_set(self, id_i_den, RARRAY_AREF(a, 1)); + num = RARRAY_AREF(a, 0); + den = RARRAY_AREF(a, 1); + nurat_int_check(num); + nurat_int_check(den); + nurat_canonicalize(&num, &den); + rb_ivar_set(self, id_i_num, num); + rb_ivar_set(self, id_i_den, den); return self; } -/* --- */ - VALUE rb_rational_reciprocal(VALUE x) { get_dat1(x); - return f_rational_new_no_reduce2(CLASS_OF(x), dat->den, dat->num); + return nurat_convert(CLASS_OF(x), dat->den, dat->num, FALSE); } /* * call-seq: - * int.gcd(int2) -> integer + * int.gcd(other_int) -> integer * - * Returns the greatest common divisor (always positive). 0.gcd(x) - * and x.gcd(0) return abs(x). + * Returns the greatest common divisor of the two integers. + * The result is always positive. 0.gcd(x) and x.gcd(0) return x.abs. * + * 36.gcd(60) #=> 12 * 2.gcd(2) #=> 2 * 3.gcd(-7) #=> 1 * ((1<<31)-1).gcd((1<<61)-1) #=> 1 @@ -1750,11 +1952,12 @@ rb_gcd(VALUE self, VALUE other) /* * call-seq: - * int.lcm(int2) -> integer + * int.lcm(other_int) -> integer * - * Returns the least common multiple (always positive). 0.lcm(x) and - * x.lcm(0) return zero. + * Returns the least common multiple of the two integers. + * The result is always positive. 0.lcm(x) and x.lcm(0) return zero. * + * 36.lcm(60) #=> 180 * 2.lcm(2) #=> 2 * 3.lcm(-7) #=> 21 * ((1<<31)-1).lcm((1<<61)-1) #=> 4951760154835678088235319297 @@ -1768,10 +1971,12 @@ rb_lcm(VALUE self, VALUE other) /* * call-seq: - * int.gcdlcm(int2) -> array + * int.gcdlcm(other_int) -> array * - * Returns an array; [int.gcd(int2), int.lcm(int2)]. + * Returns an array with the greatest common divisor and + * the least common multiple of the two integers, [gcd, lcm]. * + * 36.gcdlcm(60) #=> [12, 180] * 2.gcdlcm(2) #=> [2, 2] * 3.gcdlcm(-7) #=> [1, 21] * ((1<<31)-1).gcdlcm((1<<61)-1) #=> [1, 4951760154835678088235319297] @@ -1786,6 +1991,14 @@ rb_gcdlcm(VALUE self, VALUE other) VALUE rb_rational_raw(VALUE x, VALUE y) { + if (! RB_INTEGER_TYPE_P(x)) + x = rb_to_int(x); + if (! RB_INTEGER_TYPE_P(y)) + y = rb_to_int(y); + if (INT_NEGATIVE_P(y)) { + x = rb_int_uminus(x); + y = rb_int_uminus(y); + } return nurat_s_new_internal(rb_cRational, x, y); } @@ -1795,8 +2008,6 @@ rb_rational_new(VALUE x, VALUE y) return nurat_s_canonicalize_internal(rb_cRational, x, y); } -static VALUE nurat_s_convert(int argc, VALUE *argv, VALUE klass); - VALUE rb_Rational(VALUE x, VALUE y) { @@ -1806,13 +2017,25 @@ rb_Rational(VALUE x, VALUE y) return nurat_s_convert(2, a, rb_cRational); } +VALUE +rb_rational_num(VALUE rat) +{ + return nurat_numerator(rat); +} + +VALUE +rb_rational_den(VALUE rat) +{ + return nurat_denominator(rat); +} + #define id_numerator rb_intern("numerator") #define f_numerator(x) rb_funcall((x), id_numerator, 0) #define id_denominator rb_intern("denominator") #define f_denominator(x) rb_funcall((x), id_denominator, 0) -#define id_to_r rb_intern("to_r") +#define id_to_r idTo_r #define f_to_r(x) rb_funcall((x), id_to_r, 0) /* @@ -1845,51 +2068,32 @@ numeric_denominator(VALUE self) * num.quo(int_or_rat) -> rat * num.quo(flo) -> flo * - * Returns most exact division (rational for integers, float for floats). + * Returns the most exact division (rational for integers, float for floats). */ -static VALUE -numeric_quo(VALUE x, VALUE y) +VALUE +rb_numeric_quo(VALUE x, VALUE y) { - if (RB_TYPE_P(y, T_FLOAT)) { - return f_fdiv(x, y); + if (RB_TYPE_P(x, T_COMPLEX)) { + return rb_complex_div(x, y); } -#ifdef CANON - if (canonicalization) { - x = rb_rational_raw1(x); - } - else -#endif - { - x = rb_convert_type(x, T_RATIONAL, "Rational", "to_r"); + if (RB_FLOAT_TYPE_P(y)) { + return rb_funcallv(x, idFdiv, 1, &y); } - return rb_funcall(x, '/', 1, y); -} - -/* - * call-seq: - * int.numerator -> self - * - * Returns self. - */ -static VALUE -integer_numerator(VALUE self) -{ - return self; + x = rb_convert_type(x, T_RATIONAL, "Rational", "to_r"); + return rb_rational_div(x, y); } -/* - * call-seq: - * int.denominator -> 1 - * - * Returns 1. - */ -static VALUE -integer_denominator(VALUE self) +VALUE +rb_rational_canonicalize(VALUE x) { - return INT2FIX(1); + if (RB_TYPE_P(x, T_RATIONAL)) { + get_dat1(x); + if (f_one_p(dat->den)) return dat->num; + } + return x; } /* @@ -1901,14 +2105,18 @@ integer_denominator(VALUE self) * n = 0.3.numerator #=> 5404319552844595 * d = 0.3.denominator #=> 18014398509481984 * n.fdiv(d) #=> 0.3 + * + * See also Float#denominator. */ -static VALUE -float_numerator(VALUE self) +VALUE +rb_float_numerator(VALUE self) { double d = RFLOAT_VALUE(self); - if (isinf(d) || isnan(d)) - return self; - return rb_call_super(0, 0); + VALUE r; + if (!isfinite(d)) + return self; + r = float_to_r(self); + return nurat_numerator(r); } /* @@ -1918,41 +2126,17 @@ float_numerator(VALUE self) * Returns the denominator (always positive). The result is machine * dependent. * - * See numerator. + * See also Float#numerator. */ -static VALUE -float_denominator(VALUE self) +VALUE +rb_float_denominator(VALUE self) { double d = RFLOAT_VALUE(self); - if (isinf(d) || isnan(d)) - return INT2FIX(1); - return rb_call_super(0, 0); -} - -/* - * 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_scan_args(argc, argv, "01", NULL); - return nilclass_to_r(self); + VALUE r; + if (!isfinite(d)) + return INT2FIX(1); + r = float_to_r(self); + return nurat_denominator(r); } /* @@ -1974,78 +2158,66 @@ integer_to_r(VALUE self) * call-seq: * int.rationalize([eps]) -> rational * - * Returns the value as a rational. The optional argument eps is + * Returns the value as a rational. The optional argument +eps+ is * always ignored. */ static VALUE integer_rationalize(int argc, VALUE *argv, VALUE self) { - rb_scan_args(argc, argv, "01", NULL); + rb_check_arity(argc, 0, 1); return integer_to_r(self); } static void -float_decode_internal(VALUE self, VALUE *rf, VALUE *rn) +float_decode_internal(VALUE self, VALUE *rf, int *n) { double f; - int n; - f = frexp(RFLOAT_VALUE(self), &n); + f = frexp(RFLOAT_VALUE(self), n); f = ldexp(f, DBL_MANT_DIG); - n -= DBL_MANT_DIG; + *n -= DBL_MANT_DIG; *rf = rb_dbl2big(f); - *rn = INT2FIX(n); } -#if 0 -static VALUE -float_decode(VALUE self) -{ - VALUE f, n; - - float_decode_internal(self, &f, &n); - return rb_assoc_new(f, n); -} -#endif - -#define id_lshift rb_intern("<<") -#define f_lshift(x,n) rb_funcall((x), id_lshift, 1, (n)) - /* * 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. - * * 2.0.to_r #=> (2/1) * 2.5.to_r #=> (5/2) * -0.75.to_r #=> (-3/4) * 0.0.to_r #=> (0/1) + * 0.3.to_r #=> (5404319552844595/18014398509481984) + * + * 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. * - * See rationalize. + * 0.3.to_r == 3/10r #=> false + * "0.3".to_r == 3/10r #=> true + * + * See also Float#rationalize. */ static VALUE float_to_r(VALUE self) { - VALUE f, n; + VALUE f; + int 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))); - } + if (n == 0) + return rb_rational_new1(f); + if (n > 0) + return rb_rational_new1(rb_int_lshift(f, INT2FIX(n))); + n = -n; + return rb_rational_new2(f, rb_int_lshift(ONE, INT2FIX(n))); #else - return f_to_r(f_mul(f, f_expt(INT2FIX(FLT_RADIX), n))); + f = rb_int_mul(f, rb_int_pow(INT2FIX(FLT_RADIX), n)); + if (RB_TYPE_P(f, T_RATIONAL)) + return f; + return rb_rational_new1(f); #endif } @@ -2059,7 +2231,7 @@ rb_flt_rationalize_with_prec(VALUE flt, VALUE prec) b = f_add(flt, e); if (f_eqeq_p(a, b)) - return f_to_r(flt); + return float_to_r(flt); nurat_rationalize_internal(a, b, &p, &q); return rb_rational_new2(p, q); @@ -2068,37 +2240,32 @@ rb_flt_rationalize_with_prec(VALUE flt, VALUE prec) VALUE rb_flt_rationalize(VALUE flt) { - VALUE a, b, f, n, p, q; + VALUE a, b, f, p, q, den; + int n; float_decode_internal(flt, &f, &n); - if (f_zero_p(f) || f_positive_p(n)) - return rb_rational_new1(f_lshift(f, n)); + if (INT_ZERO_P(f) || n >= 0) + return rb_rational_new1(rb_int_lshift(f, INT2FIX(n))); -#if FLT_RADIX == 2 { - VALUE two_times_f, den; - - two_times_f = f_mul(TWO, f); - den = f_lshift(ONE, f_sub(ONE, n)); + VALUE radix_times_f; - a = rb_rational_new2(f_sub(two_times_f, ONE), den); - b = rb_rational_new2(f_add(two_times_f, ONE), den); - } + radix_times_f = rb_int_mul(INT2FIX(FLT_RADIX), f); +#if FLT_RADIX == 2 && 0 + den = rb_int_lshift(ONE, INT2FIX(1-n)); #else - { - VALUE radix_times_f, den; - - radix_times_f = f_mul(INT2FIX(FLT_RADIX), f); - den = f_expt(INT2FIX(FLT_RADIX), f_sub(ONE, n)); + den = rb_int_positive_pow(FLT_RADIX, 1-n); +#endif - a = rb_rational_new2(f_sub(radix_times_f, INT2FIX(FLT_RADIX - 1)), den); - b = rb_rational_new2(f_add(radix_times_f, INT2FIX(FLT_RADIX - 1)), den); + a = rb_int_minus(radix_times_f, INT2FIX(FLT_RADIX - 1)); + b = rb_int_plus(radix_times_f, INT2FIX(FLT_RADIX - 1)); } -#endif if (f_eqeq_p(a, b)) - return f_to_r(flt); + return float_to_r(flt); + a = rb_rational_new2(a, den); + b = rb_rational_new2(b, den); nurat_rationalize_internal(a, b, &p, &q); return rb_rational_new2(p, q); } @@ -2108,35 +2275,33 @@ rb_flt_rationalize(VALUE flt) * flt.rationalize([eps]) -> rational * * Returns a simpler approximation of the value (flt-|eps| <= result - * <= flt+|eps|). if the optional eps is not given, it will be chosen - * automatically. + * <= flt+|eps|). If the optional argument +eps+ is not given, + * it will be chosen automatically. * * 0.3.rationalize #=> (3/10) * 1.333.rationalize #=> (1333/1000) * 1.333.rationalize(0.01) #=> (4/3) * - * See to_r. + * See also Float#to_r. */ static VALUE float_rationalize(int argc, VALUE *argv, VALUE self) { - VALUE e; - - if (f_negative_p(self)) - return f_negate(float_rationalize(argc, argv, f_abs(self))); - - rb_scan_args(argc, argv, "01", &e); + double d = RFLOAT_VALUE(self); + VALUE rat; + int neg = d < 0.0; + if (neg) self = DBL2NUM(-d); - if (argc != 0) { - return rb_flt_rationalize_with_prec(self, e); + if (rb_check_arity(argc, 0, 1)) { + rat = rb_flt_rationalize_with_prec(self, argv[0]); } else { - return rb_flt_rationalize(self); + rat = rb_flt_rationalize(self); } + if (neg) RATIONAL_SET_NUM(rat, rb_int_uminus(RRATIONAL(rat)->num)); + return rat; } -#include <ctype.h> - inline static int issign(int c) { @@ -2144,260 +2309,246 @@ issign(int c) } static int -read_sign(const char **s) +read_sign(const char **s, const char *const e) { int sign = '?'; - if (issign(**s)) { - sign = **s; - (*s)++; + if (*s < e && issign(**s)) { + sign = **s; + (*s)++; } return sign; } inline static int -isdecimal(int c) -{ - return isdigit((unsigned char)c); -} - -static int -read_digits(const char **s, int strict, - VALUE *num, int *count) -{ - char *b, *bb; - int us = 1, ret = 1; - - if (!isdecimal(**s)) { - *num = ZERO; - return 0; - } - - bb = b = ALLOCA_N(char, strlen(*s) + 1); - - while (isdecimal(**s) || **s == '_') { - if (**s == '_') { - if (strict) { - if (us) { - ret = 0; - goto conv; - } - } - us = 1; - } - else { - if (count) - (*count)++; - *b++ = **s; - us = 0; - } - (*s)++; - } - if (us) - do { - (*s)--; - } while (**s == '_'); - conv: - *b = '\0'; - *num = rb_cstr_to_inum(bb, 10, 0); - return ret; -} - -inline static int islettere(int c) { return (c == 'e' || c == 'E'); } -static int -read_num(const char **s, int numsign, int strict, - VALUE *num) -{ - VALUE ip, fp, exp; - - *num = rb_rational_new2(ZERO, ONE); - exp = Qnil; - - if (**s != '.') { - if (!read_digits(s, strict, &ip, NULL)) - return 0; - *num = rb_rational_new2(ip, ONE); - } - - if (**s == '.') { - int count = 0; - - (*s)++; - if (!read_digits(s, strict, &fp, &count)) - return 0; - { - VALUE l = f_expt10(INT2NUM(count)); - *num = f_mul(*num, l); - *num = f_add(*num, fp); - *num = f_div(*num, l); - } - } - - if (islettere(**s)) { - int expsign; - - (*s)++; - expsign = read_sign(s); - if (!read_digits(s, strict, &exp, NULL)) - return 0; - if (expsign == '-') - exp = f_negate(exp); - } - - if (numsign == '-') - *num = f_negate(*num); - if (!NIL_P(exp)) { - VALUE l = f_expt10(exp); - *num = f_mul(*num, l); - } - return 1; -} - inline static int -read_den(const char **s, int strict, - VALUE *num) +isletterr(int c) { - if (!read_digits(s, strict, num, NULL)) - return 0; - return 1; + return (c == 'r' || c == 'R'); } -static int -read_rat_nos(const char **s, int sign, int strict, - VALUE *num) +static VALUE +negate_num(VALUE num) { - VALUE den; - - if (!read_num(s, sign, strict, num)) - return 0; - if (**s == '/') { - (*s)++; - if (!read_den(s, strict, &den)) - return 0; - if (!(FIXNUM_P(den) && FIX2LONG(den) == 1)) - *num = f_div(*num, den); + if (FIXNUM_P(num)) { + return rb_int_uminus(num); + } + else { + BIGNUM_NEGATE(num); + return rb_big_norm(num); } - return 1; } static int -read_rat(const char **s, int strict, - VALUE *num) -{ - int sign; - - sign = read_sign(s); - if (!read_rat_nos(s, sign, strict, num)) - return 0; - return 1; -} - -inline static void -skip_ws(const char **s) -{ - while (isspace((unsigned char)**s)) - (*s)++; +read_num(const char **s, const char *const end, VALUE *num, VALUE *nexp) +{ + VALUE fp = ONE, exp, fn = ZERO, n = ZERO; + int expsign = 0, ok = 0; + char *e; + + *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; + } + + 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; + { + 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 >= 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; +} + +inline static const char * +skip_ws(const char *s, const char *e) +{ + while (s < e && isspace((unsigned char)*s)) + ++s; + return s; } -static int -parse_rat(const char *s, int strict, - VALUE *num) +static VALUE +parse_rat(const char *s, const char *const e, int strict, int raise) { - skip_ws(&s); - if (!read_rat(&s, strict, num)) - return 0; - skip_ws(&s); - - if (strict) - if (*s != '\0') - return 0; - return 1; + int sign; + VALUE num, den, nexp, dexp; + + s = skip_ws(s, e); + sign = read_sign(&s, e); + + if (!read_num(&s, e, &num, &nexp)) { + if (strict) return Qnil; + return nurat_s_alloc(rb_cRational); + } + den = ONE; + if (s < e && *s == '/') { + s++; + if (!read_num(&s, e, &den, &dexp)) { + if (strict) return Qnil; + den = ONE; + } + else if (den == ZERO) { + if (!raise) return Qnil; + rb_num_zerodiv(); + } + else if (strict && skip_ws(s, e) != e) { + return Qnil; + } + else { + nexp = rb_int_minus(nexp, dexp); + nurat_reduce(&num, &den); + } + } + else if (strict && skip_ws(s, e) != e) { + return Qnil; + } + + if (nexp != ZERO) { + if (INT_NEGATIVE_P(nexp)) { + VALUE mul; + if (FIXNUM_P(nexp)) { + mul = f_expt10(LONG2NUM(-FIX2LONG(nexp))); + if (! RB_FLOAT_TYPE_P(mul)) { + num = rb_int_mul(num, mul); + goto reduce; + } + } + return sign == '-' ? DBL2NUM(-HUGE_VAL) : DBL2NUM(HUGE_VAL); + } + else { + VALUE div; + if (FIXNUM_P(nexp)) { + div = f_expt10(nexp); + if (! RB_FLOAT_TYPE_P(div)) { + den = rb_int_mul(den, div); + goto reduce; + } + } + return sign == '-' ? DBL2NUM(-0.0) : DBL2NUM(+0.0); + } + reduce: + nurat_reduce(&num, &den); + } + + if (sign == '-') { + num = negate_num(num); + } + + return rb_rational_raw(num, den); } static VALUE -string_to_r_strict(VALUE self) +string_to_r_strict(VALUE self, int raise) { - char *s; VALUE num; rb_must_asciicompat(self); - s = RSTRING_PTR(self); - - if (!s || memchr(s, '\0', RSTRING_LEN(self))) - rb_raise(rb_eArgError, "string contains null byte"); - - if (s && s[RSTRING_LEN(self)]) { - rb_str_modify(self); - s = RSTRING_PTR(self); - s[RSTRING_LEN(self)] = '\0'; + num = parse_rat(RSTRING_PTR(self), RSTRING_END(self), 1, raise); + if (NIL_P(num)) { + if (!raise) return Qnil; + rb_raise(rb_eArgError, "invalid value for convert(): %+"PRIsVALUE, + self); } - if (!s) - s = (char *)""; - - if (!parse_rat(s, 1, &num)) { - VALUE ins = f_inspect(self); - rb_raise(rb_eArgError, "invalid value for convert(): %s", - StringValuePtr(ins)); + if (RB_FLOAT_TYPE_P(num) && !FLOAT_ZERO_P(num)) { + if (!raise) return Qnil; + rb_raise(rb_eFloatDomainError, "Infinity"); } - - if (RB_TYPE_P(num, T_FLOAT)) - rb_raise(rb_eFloatDomainError, "Infinity"); return num; } /* * call-seq: - * str.to_r -> rational - * - * Returns a rational which denotes the string form. The parser - * ignores leading whitespaces and trailing garbage. Any digit - * sequences can be separated by an underscore. Returns zero for null - * or garbage string. - * - * 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. - * - * ' 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) - * - * See Kernel.Rational. + * str.to_r -> rational + * + * 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) + * + * 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) { - char *s; VALUE num; rb_must_asciicompat(self); - s = RSTRING_PTR(self); - - if (s && s[RSTRING_LEN(self)]) { - rb_str_modify(self); - s = RSTRING_PTR(self); - s[RSTRING_LEN(self)] = '\0'; - } - - if (!s) - s = (char *)""; - - (void)parse_rat(s, 0, &num); + num = parse_rat(RSTRING_PTR(self), RSTRING_END(self), 0, TRUE); - if (RB_TYPE_P(num, T_FLOAT)) - rb_raise(rb_eFloatDomainError, "Infinity"); + if (RB_FLOAT_TYPE_P(num) && !FLOAT_ZERO_P(num)) + rb_raise(rb_eFloatDomainError, "Infinity"); return num; } @@ -2406,89 +2557,187 @@ rb_cstr_to_rat(const char *s, int strict) /* for complex's internal */ { VALUE num; - (void)parse_rat(s, strict, &num); + num = parse_rat(s, s + strlen(s), strict, TRUE); - if (RB_TYPE_P(num, T_FLOAT)) - rb_raise(rb_eFloatDomainError, "Infinity"); + if (RB_FLOAT_TYPE_P(num) && !FLOAT_ZERO_P(num)) + rb_raise(rb_eFloatDomainError, "Infinity"); return num; } static VALUE -nurat_s_convert(int argc, VALUE *argv, VALUE klass) +to_rational(VALUE val) +{ + return rb_convert_type_with_id(val, T_RATIONAL, "Rational", idTo_r); +} + +static VALUE +nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise) { - VALUE a1, a2, backref; + VALUE a1 = numv, a2 = denv; + int state; - rb_scan_args(argc, argv, "11", &a1, &a2); + RUBY_ASSERT(!UNDEF_P(a1)); - if (NIL_P(a1) || (argc == 2 && NIL_P(a2))) - rb_raise(rb_eTypeError, "can't convert nil into Rational"); + if (NIL_P(a1) || NIL_P(a2)) { + if (!raise) return Qnil; + rb_cant_convert(Qnil, "Rational"); + } if (RB_TYPE_P(a1, T_COMPLEX)) { - if (k_exact_zero_p(RCOMPLEX(a1)->imag)) - a1 = RCOMPLEX(a1)->real; + if (k_exact_zero_p(RCOMPLEX(a1)->imag)) + a1 = RCOMPLEX(a1)->real; } if (RB_TYPE_P(a2, T_COMPLEX)) { - if (k_exact_zero_p(RCOMPLEX(a2)->imag)) - a2 = RCOMPLEX(a2)->real; + if (k_exact_zero_p(RCOMPLEX(a2)->imag)) + a2 = RCOMPLEX(a2)->real; } - backref = rb_backref_get(); - rb_match_busy(backref); - - if (RB_TYPE_P(a1, T_FLOAT)) { - a1 = f_to_r(a1); + if (RB_INTEGER_TYPE_P(a1)) { + // nothing to do + } + else if (RB_FLOAT_TYPE_P(a1)) { + a1 = float_to_r(a1); + } + else if (RB_TYPE_P(a1, T_RATIONAL)) { + // nothing to do } else if (RB_TYPE_P(a1, T_STRING)) { - a1 = string_to_r_strict(a1); + a1 = string_to_r_strict(a1, raise); + if (!raise && NIL_P(a1)) return Qnil; + } + else if (!rb_respond_to(a1, idTo_r)) { + VALUE tmp = rb_protect(rb_check_to_int, a1, NULL); + rb_set_errinfo(Qnil); + if (!NIL_P(tmp)) { + a1 = tmp; + } } - if (RB_TYPE_P(a2, T_FLOAT)) { - a2 = f_to_r(a2); + if (RB_INTEGER_TYPE_P(a2)) { + // nothing to do + } + else if (RB_FLOAT_TYPE_P(a2)) { + a2 = float_to_r(a2); + } + else if (RB_TYPE_P(a2, T_RATIONAL)) { + // nothing to do } else if (RB_TYPE_P(a2, T_STRING)) { - a2 = string_to_r_strict(a2); + a2 = string_to_r_strict(a2, raise); + if (!raise && NIL_P(a2)) return Qnil; + } + 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)) { + a2 = tmp; + } } - - rb_backref_set(backref); if (RB_TYPE_P(a1, T_RATIONAL)) { - if (argc == 1 || (k_exact_one_p(a2))) - return a1; + if (UNDEF_P(a2) || (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"); + if (UNDEF_P(a2)) { + if (!RB_INTEGER_TYPE_P(a1)) { + if (!raise) { + VALUE result = rb_protect(to_rational, a1, NULL); + rb_set_errinfo(Qnil); + return result; + } + return to_rational(a1); + } } else { - if ((k_numeric_p(a1) && k_numeric_p(a2)) && - (!f_integer_p(a1) || !f_integer_p(a2))) - return f_div(a1, a2); + if (!k_numeric_p(a1)) { + if (!raise) { + a1 = rb_protect(to_rational, a1, &state); + if (state) { + rb_set_errinfo(Qnil); + return Qnil; + } + } + else { + a1 = rb_check_convert_type_with_id(a1, T_RATIONAL, "Rational", idTo_r); + } + } + if (!k_numeric_p(a2)) { + if (!raise) { + a2 = rb_protect(to_rational, a2, &state); + if (state) { + rb_set_errinfo(Qnil); + return Qnil; + } + } + else { + a2 = rb_check_convert_type_with_id(a2, T_RATIONAL, "Rational", idTo_r); + } + } + if ((k_numeric_p(a1) && k_numeric_p(a2)) && + (!f_integer_p(a1) || !f_integer_p(a2))) { + VALUE tmp = rb_protect(to_rational, a1, &state); + if (!state) { + a1 = tmp; + } + else { + rb_set_errinfo(Qnil); + } + return f_div(a1, a2); + } + } + + a1 = nurat_int_value(a1); + + if (UNDEF_P(a2)) { + a2 = ONE; + } + else if (!k_integer_p(a2) && !raise) { + return Qnil; + } + else { + a2 = nurat_int_value(a2); } - { - VALUE argv2[2]; - argv2[0] = a1; - argv2[1] = a2; - return nurat_s_new(argc, argv2, klass); + + return nurat_s_canonicalize_internal(klass, a1, a2); +} + +static VALUE +nurat_s_convert(int argc, VALUE *argv, VALUE klass) +{ + VALUE a1, a2; + + if (rb_scan_args(argc, argv, "11", &a1, &a2) == 1) { + a2 = Qundef; } + + return nurat_convert(klass, a1, a2, TRUE); } /* - * A rational number can be represented as a paired integer number; - * a/b (b>0). Where a is numerator and b is denominator. Integer a - * equals rational a/1 mathematically. + * A rational number can be represented as a pair of integer numbers: + * a/b (b>0), where a is the numerator and b is the denominator. + * Integer a equals rational a/1 mathematically. + * + * You can create a \Rational object explicitly with: * - * In ruby, you can create rational object with Rational, to_r or - * rationalize method. The return values will be irreducible. + * - 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) * - * You can also create rational object from floating-point numbers or + * You can also create rational objects from floating-point numbers or * strings. * * Rational(0.3) #=> (5404319552844595/18014398509481984) @@ -2501,13 +2750,13 @@ nurat_s_convert(int argc, VALUE *argv, VALUE klass) * 0.3.rationalize #=> (3/10) * * A rational object is an exact number, which helps you to write - * program without any rounding errors. + * programs without any rounding errors. * - * 10.times.inject(0){|t,| t + 0.1} #=> 0.9999999999999999 - * 10.times.inject(0){|t,| t + Rational('0.1')} #=> (1/1) + * 10.times.inject(0) {|t| t + 0.1 } #=> 0.9999999999999999 + * 10.times.inject(0) {|t| t + Rational('0.1') } #=> (1/1) * - * However, when an expression has inexact factor (numerical value or - * operation), will produce an inexact result. + * However, when an expression includes an inexact component (numerical value + * or operation), it will produce an inexact result. * * Rational(10) / 3 #=> (10/3) * Rational(10) / 3.0 #=> 3.3333333333333335 @@ -2519,69 +2768,40 @@ void Init_Rational(void) { VALUE compat; -#undef rb_intern -#define rb_intern(str) rb_intern_const(str) - - assert(fprintf(stderr, "assert() is now active\n")); - - id_abs = rb_intern("abs"); - id_cmp = rb_intern("<=>"); - id_convert = rb_intern("convert"); - id_eqeq_p = rb_intern("=="); - id_expt = rb_intern("**"); - id_fdiv = rb_intern("fdiv"); - id_floor = rb_intern("floor"); - id_idiv = rb_intern("div"); - id_integer_p = rb_intern("integer?"); - id_negate = rb_intern("-@"); - id_to_f = rb_intern("to_f"); - id_to_i = rb_intern("to_i"); - id_truncate = rb_intern("truncate"); - id_i_num = rb_intern("@numerator"); - id_i_den = rb_intern("@denominator"); + id_abs = rb_intern_const("abs"); + id_integer_p = rb_intern_const("integer?"); + id_i_num = rb_intern_const("@numerator"); + id_i_den = rb_intern_const("@denominator"); rb_cRational = rb_define_class("Rational", rb_cNumeric); rb_define_alloc_func(rb_cRational, nurat_s_alloc); rb_undef_method(CLASS_OF(rb_cRational), "allocate"); -#if 0 - rb_define_private_method(CLASS_OF(rb_cRational), "new!", nurat_s_new_bang, -1); - rb_define_private_method(CLASS_OF(rb_cRational), "new", nurat_s_new, -1); -#else rb_undef_method(CLASS_OF(rb_cRational), "new"); -#endif rb_define_global_function("Rational", nurat_f_rational, -1); rb_define_method(rb_cRational, "numerator", nurat_numerator, 0); rb_define_method(rb_cRational, "denominator", nurat_denominator, 0); - rb_define_method(rb_cRational, "+", nurat_add, 1); - rb_define_method(rb_cRational, "-", nurat_sub, 1); - rb_define_method(rb_cRational, "*", nurat_mul, 1); - rb_define_method(rb_cRational, "/", nurat_div, 1); - rb_define_method(rb_cRational, "quo", nurat_div, 1); - rb_define_method(rb_cRational, "fdiv", nurat_fdiv, 1); + rb_define_method(rb_cRational, "-@", rb_rational_uminus, 0); + rb_define_method(rb_cRational, "+", rb_rational_plus, 1); + rb_define_method(rb_cRational, "-", rb_rational_minus, 1); + 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", rb_rational_fdiv, 1); rb_define_method(rb_cRational, "**", nurat_expt, 1); - rb_define_method(rb_cRational, "<=>", nurat_cmp, 1); + rb_define_method(rb_cRational, "<=>", rb_rational_cmp, 1); rb_define_method(rb_cRational, "==", nurat_eqeq_p, 1); rb_define_method(rb_cRational, "coerce", nurat_coerce, 1); -#if 0 /* NUBY */ - rb_define_method(rb_cRational, "//", nurat_idiv, 1); -#endif - -#if 0 - rb_define_method(rb_cRational, "quot", nurat_quot, 1); - rb_define_method(rb_cRational, "quotrem", nurat_quotrem, 1); -#endif - -#if 0 - rb_define_method(rb_cRational, "rational?", nurat_true, 0); - rb_define_method(rb_cRational, "exact?", nurat_true, 0); -#endif + rb_define_method(rb_cRational, "positive?", nurat_positive_p, 0); + rb_define_method(rb_cRational, "negative?", nurat_negative_p, 0); + rb_define_method(rb_cRational, "abs", rb_rational_abs, 0); + rb_define_method(rb_cRational, "magnitude", rb_rational_abs, 0); rb_define_method(rb_cRational, "floor", nurat_floor_n, -1); rb_define_method(rb_cRational, "ceil", nurat_ceil_n, -1); @@ -2599,28 +2819,22 @@ Init_Rational(void) rb_define_method(rb_cRational, "inspect", nurat_inspect, 0); rb_define_private_method(rb_cRational, "marshal_dump", nurat_marshal_dump, 0); + /* :nodoc: */ compat = rb_define_class_under(rb_cRational, "compatible", rb_cObject); 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); rb_define_method(rb_cNumeric, "numerator", numeric_numerator, 0); rb_define_method(rb_cNumeric, "denominator", numeric_denominator, 0); - rb_define_method(rb_cNumeric, "quo", 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_cNumeric, "quo", rb_numeric_quo, 1); - rb_define_method(rb_cFloat, "numerator", float_numerator, 0); - rb_define_method(rb_cFloat, "denominator", float_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); @@ -2629,10 +2843,6 @@ Init_Rational(void) rb_define_method(rb_cString, "to_r", string_to_r, 0); rb_define_private_method(CLASS_OF(rb_cRational), "convert", nurat_s_convert, -1); -} -/* -Local variables: -c-file-style: "ruby" -End: -*/ + rb_provide("rational.so"); /* for backward compatibility */ +} |