summaryrefslogtreecommitdiff
path: root/rational.c
diff options
context:
space:
mode:
Diffstat (limited to 'rational.c')
-rw-r--r--rational.c1507
1 files changed, 771 insertions, 736 deletions
diff --git a/rational.c b/rational.c
index 7113e15e8e..51078f81ad 100644
--- a/rational.c
+++ b/rational.c
@@ -5,21 +5,41 @@
which is written in ruby.
*/
-#include "internal.h"
-#include "id.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
+#if !defined(USE_GMP)
+#if defined(HAVE_LIBGMP) && defined(HAVE_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/gc.h"
+#include "internal/numeric.h"
+#include "internal/object.h"
+#include "internal/rational.h"
#include "ruby_assert.h"
-#if defined(HAVE_LIBGMP) && defined(HAVE_GMP_H)
-#define USE_GMP
-#include <gmp.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,42 +48,31 @@
#define GMP_GCD_DIGITS 1
-#define INT_POSITIVE_P(x) (FIXNUM_P(x) ? FIXNUM_POSITIVE_P(x) : BIGNUM_POSITIVE_P(x))
#define INT_ZERO_P(x) (FIXNUM_P(x) ? FIXNUM_ZERO_P(x) : rb_bigzero_p(x))
VALUE rb_cRational;
-static ID id_abs, id_idiv, id_integer_p,
+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
static VALUE nurat_to_f(VALUE self);
-
-#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);\
-}
+static VALUE float_to_r(VALUE self);
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 +80,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,26 +90,36 @@ 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);
+ }
return RTEST(rb_funcall(x, '<', 1, y));
}
#ifndef NDEBUG
/* f_mod is used only in f_gcd defined when NDEBUG is not defined */
-binop(mod, '%')
+inline static VALUE
+f_mod(VALUE x, VALUE y)
+{
+ if (RB_INTEGER_TYPE_P(x))
+ return rb_int_modulo(x, y);
+ return rb_funcall(x, '%', 1, y);
+}
#endif
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);
}
@@ -108,7 +127,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);
}
@@ -116,25 +135,32 @@ 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);
}
-fun1(integer_p)
+
+inline static int
+f_integer_p(VALUE x)
+{
+ return RB_INTEGER_TYPE_P(x);
+}
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);
}
-inline static VALUE
+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);
}
@@ -142,7 +168,7 @@ inline static VALUE
f_idiv(VALUE x, VALUE y)
{
if (RB_INTEGER_TYPE_P(x))
- return rb_int_idiv(x, y);
+ return rb_int_idiv(x, y);
return rb_funcall(x, id_idiv, 1, y);
}
@@ -152,12 +178,12 @@ inline static int
f_zero_p(VALUE x)
{
if (RB_INTEGER_TYPE_P(x)) {
- return FIXNUM_ZERO_P(x);
+ return FIXNUM_ZERO_P(x);
}
else if (RB_TYPE_P(x, T_RATIONAL)) {
- VALUE num = RRATIONAL(x)->num;
+ VALUE num = RRATIONAL(x)->num;
- return FIXNUM_ZERO_P(num);
+ return FIXNUM_ZERO_P(num);
}
return (int)rb_equal(x, ZERO);
}
@@ -168,13 +194,13 @@ inline static int
f_one_p(VALUE x)
{
if (RB_INTEGER_TYPE_P(x)) {
- return x == LONG2FIX(1);
+ return x == LONG2FIX(1);
}
else if (RB_TYPE_P(x, T_RATIONAL)) {
- VALUE num = RRATIONAL(x)->num;
- VALUE den = RRATIONAL(x)->den;
+ VALUE num = RRATIONAL(x)->num;
+ VALUE den = RRATIONAL(x)->den;
- return num == LONG2FIX(1) && den == LONG2FIX(1);
+ return num == LONG2FIX(1) && den == LONG2FIX(1);
}
return (int)rb_equal(x, ONE);
}
@@ -183,16 +209,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));
}
@@ -233,7 +259,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)
{
@@ -275,35 +301,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);
@@ -315,28 +341,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 */
}
@@ -350,8 +376,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)
@@ -369,8 +395,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;
}
@@ -380,7 +406,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));
}
@@ -393,11 +419,12 @@ f_lcm(VALUE x, VALUE y)
inline static VALUE
nurat_s_new_internal(VALUE klass, VALUE num, VALUE den)
{
- NEWOBJ_OF(obj, struct RRational, klass, T_RATIONAL | (RGENGC_WB_PROTECTED_RATIONAL ? FL_WB_PROTECTED : 0));
+ NEWOBJ_OF(obj, struct RRational, klass, T_RATIONAL | (RGENGC_WB_PROTECTED_RATIONAL ? FL_WB_PROTECTED : 0),
+ sizeof(struct RRational), 0);
- RRATIONAL_SET_NUM(obj, num);
- RRATIONAL_SET_DEN(obj, den);
- OBJ_FREEZE_RAW(obj);
+ RATIONAL_SET_NUM((VALUE)obj, num);
+ RATIONAL_SET_DEN((VALUE)obj, den);
+ OBJ_FREEZE((VALUE)obj);
return (VALUE)obj;
}
@@ -414,24 +441,12 @@ f_rational_new_bang1(VALUE klass, VALUE x)
return nurat_s_new_internal(klass, x, ONE);
}
-#ifdef CANONICALIZATION_FOR_MATHN
-static int canonicalization = 0;
-
-RUBY_FUNC_EXPORTED void
-nurat_canonicalization(int f)
-{
- canonicalization = f;
-}
-#else
-# define canonicalization 0
-#endif
-
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");
}
}
@@ -440,15 +455,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);
@@ -474,8 +489,6 @@ nurat_s_canonicalize_internal(VALUE klass, VALUE num, VALUE den)
nurat_canonicalize(&num, &den);
nurat_reduce(&num, &den);
- if (canonicalization && f_one_p(den))
- return num;
return nurat_s_new_internal(klass, num, den);
}
@@ -484,43 +497,22 @@ nurat_s_canonicalize_internal_no_reduce(VALUE klass, VALUE num, VALUE den)
{
nurat_canonicalize(&num, &den);
- if (canonicalization && f_one_p(den))
- return num;
return nurat_s_new_internal(klass, num, den);
}
-static VALUE
-nurat_s_new(int argc, VALUE *argv, VALUE klass)
-{
- 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;
- }
-
- return nurat_s_canonicalize_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_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);
}
@@ -617,14 +609,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);
@@ -640,14 +636,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;
@@ -660,7 +656,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
@@ -671,46 +667,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);
@@ -723,51 +719,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
+ *
+ * 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)
*
- * Performs addition.
+ * 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)
@@ -775,32 +782,32 @@ rb_rational_plus(VALUE self, VALUE other)
* 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_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, '-');
}
}
@@ -809,7 +816,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) ||
@@ -820,92 +827,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)
@@ -913,41 +921,41 @@ rb_rational_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_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, '/');
}
}
@@ -966,31 +974,22 @@ nurat_fdiv(VALUE self, VALUE other)
{
VALUE div;
if (f_zero_p(other))
- return nurat_div(self, rb_float_new(0.0));
+ return rb_rational_div(self, rb_float_new(0.0));
if (FIXNUM_P(other) && other == LONG2FIX(1))
- return nurat_to_f(self);
- div = nurat_div(self, other);
+ 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);
}
-inline static VALUE
-f_odd_p(VALUE integer)
-{
- if (rb_funcall(integer, '%', 1, INT2FIX(2)) != INT2FIX(0)) {
- return Qtrue;
- }
- return Qfalse;
-}
-
/*
* 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)
@@ -1003,142 +1002,152 @@ 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(f_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:
+ *
+ * - +-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.
*
- * Returns -1, 0, or +1 depending on whether +rational+ is
- * less than, equal to, or greater than +numeric+.
+ * Examples:
*
- * +nil+ is returned if the two values are incomparable.
+ * 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
*
- * 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
+ * \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)
{
- if (RB_INTEGER_TYPE_P(other)) {
- {
- get_dat1(self);
+ 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);
- goto other_is_rational;
- }
- }
- else if (RB_FLOAT_TYPE_P(other)) {
- return rb_dbl_cmp(nurat_to_double(self), RFLOAT_VALUE(other));
- }
- else if (RB_TYPE_P(other, T_RATIONAL)) {
- other_is_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);
- }
- }
- else {
- return rb_num_coerce_cmp(self, other, rb_intern("<=>"));
+ 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));
+
+ 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
@@ -1153,37 +1162,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);
}
}
@@ -1192,24 +1201,30 @@ 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(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;
}
@@ -1223,7 +1238,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));
}
/*
@@ -1236,7 +1251,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));
}
/*
@@ -1249,7 +1264,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
@@ -1296,7 +1310,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);
}
@@ -1312,14 +1326,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;
}
@@ -1336,7 +1350,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);
@@ -1344,7 +1358,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;
}
@@ -1361,17 +1375,17 @@ nurat_round_half_even(VALUE self)
neg = INT_NEGATIVE_P(num);
if (neg)
- num = rb_int_uminus(num);
+ num = rb_int_uminus(num);
num = rb_int_plus(rb_int_mul(num, TWO), den);
den = rb_int_mul(den, TWO);
qr = rb_int_divmod(num, den);
num = RARRAY_AREF(qr, 0);
if (INT_ZERO_P(RARRAY_AREF(qr, 1)))
- num = rb_int_and(num, LONG2FIX(((int)~1)));
+ num = rb_int_and(num, LONG2FIX(((int)~1)));
if (neg)
- num = rb_int_uminus(num);
+ num = rb_int_uminus(num);
return num;
}
@@ -1382,36 +1396,48 @@ f_round_common(int argc, VALUE *argv, VALUE self, VALUE (*func)(VALUE))
VALUE n, b, s;
if (rb_check_arity(argc, 0, 1) == 0)
- return (*func)(self);
+ return (*func)(self);
n = argv[0];
if (!k_integer_p(n))
- rb_raise(rb_eTypeError, "not an integer");
+ rb_raise(rb_eTypeError, "not an integer");
b = f_expt10(n);
s = rb_rational_mul(self, b);
if (k_float_p(s)) {
- if (INT_NEGATIVE_P(n))
- return ZERO;
- return self;
+ if (INT_NEGATIVE_P(n))
+ return ZERO;
+ return self;
}
if (!k_rational_p(s)) {
- s = f_rational_new_bang1(CLASS_OF(self), s);
+ s = f_rational_new_bang1(CLASS_OF(self), s);
}
s = (*func)(s);
- s = nurat_div(f_rational_new_bang1(CLASS_OF(self), s), b);
+ 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;
}
+VALUE
+rb_rational_floor(VALUE self, int ndigits)
+{
+ if (ndigits == 0) {
+ return nurat_floor(self);
+ }
+ else {
+ VALUE n = INT2NUM(ndigits);
+ return f_round_common(1, &n, self, nurat_floor);
+ }
+}
+
/*
* call-seq:
* rat.floor([ndigits]) -> integer or rational
@@ -1544,12 +1570,18 @@ 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));
+ 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(int argc, VALUE *argv, VALUE num)
+{
+ return nurat_to_f(nurat_round_n(argc, argv, float_to_r(num)));
+}
+
static double
nurat_to_double(VALUE self)
{
@@ -1593,10 +1625,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 rb_intern("quo")
-#define f_quo(x,y) rb_funcall((x), id_quo, 1, (y))
+#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));
+
+ return rb_funcallv(x, id_quo, 1, &y);
+}
#define f_reciprocal(x) f_quo(ONE, (x))
@@ -1670,19 +1720,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);
@@ -1706,27 +1756,36 @@ static VALUE
nurat_rationalize(int argc, VALUE *argv, VALUE self)
{
VALUE e, a, b, p, q;
+ VALUE rat = self;
+ get_dat1(self);
if (rb_check_arity(argc, 0, 1) == 0)
- return self;
-
- if (nurat_negative_p(self))
- return rb_rational_uminus(nurat_rationalize(argc, argv, rb_rational_uminus(self)));
+ return self;
e = f_abs(argv[0]);
- a = f_sub(self, e);
- b = f_add(self, e);
+
+ if (INT_NEGATIVE_P(dat->num)) {
+ rat = f_rational_new2(RBASIC_CLASS(self), rb_int_uminus(dat->num), dat->den);
+ }
+
+ 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;
@@ -1737,10 +1796,17 @@ nurat_hash(VALUE self)
n = rb_hash(dat->den);
h[1] = NUM2LONG(n);
v = rb_memhash(h, sizeof(h));
- return ST2FIX(v);
+ return v;
}
static VALUE
+nurat_hash(VALUE self)
+{
+ return ST2FIX(rb_rational_hash(self));
+}
+
+
+static VALUE
f_format(VALUE self, VALUE (*func)(VALUE))
{
VALUE s;
@@ -1810,9 +1876,9 @@ nurat_loader(VALUE self, VALUE a)
nurat_int_check(num);
nurat_int_check(den);
nurat_canonicalize(&num, &den);
- RRATIONAL_SET_NUM(dat, num);
- RRATIONAL_SET_DEN(dat, den);
- OBJ_FREEZE_RAW(self);
+ RATIONAL_SET_NUM((VALUE)dat, num);
+ RATIONAL_SET_DEN((VALUE)dat, den);
+ OBJ_FREEZE(self);
return self;
}
@@ -1836,11 +1902,10 @@ 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));
+ 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);
@@ -1853,13 +1918,11 @@ nurat_marshal_load(VALUE self, VALUE a)
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);
}
/*
@@ -1922,6 +1985,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);
}
@@ -1997,17 +2068,16 @@ numeric_denominator(VALUE self)
VALUE
rb_numeric_quo(VALUE x, VALUE y)
{
- if (RB_FLOAT_TYPE_P(y)) {
- return rb_funcall(x, rb_intern("fdiv"), 1, y);
+ if (RB_TYPE_P(x, T_COMPLEX)) {
+ return rb_complex_div(x, y);
}
- if (canonicalization) {
- x = rb_rational_raw1(x);
- }
- else {
- x = rb_convert_type(x, T_RATIONAL, "Rational", "to_r");
+ if (RB_FLOAT_TYPE_P(y)) {
+ return rb_funcallv(x, idFdiv, 1, &y);
}
- return nurat_div(x, y);
+
+ x = rb_convert_type(x, T_RATIONAL, "Rational", "to_r");
+ return rb_rational_div(x, y);
}
VALUE
@@ -2022,31 +2092,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);
-}
-
-static VALUE float_to_r(VALUE self);
-/*
- * call-seq:
* flo.numerator -> integer
*
* Returns the numerator. The result is machine dependent.
@@ -2062,12 +2107,9 @@ 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);
- if (canonicalization && k_integer_p(r)) {
- return r;
- }
return nurat_numerator(r);
}
@@ -2085,43 +2127,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);
- if (canonicalization && k_integer_p(r)) {
- return ONE;
- }
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.
@@ -2150,16 +2163,14 @@ integer_rationalize(int argc, VALUE *argv, VALUE 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);
}
/*
@@ -2185,24 +2196,21 @@ float_decode_internal(VALUE self, VALUE *rf, VALUE *rn)
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 rb_rational_new1(f);
- if (ln > 0)
- return rb_rational_new1(rb_int_lshift(f, n));
- ln = -ln;
- return rb_rational_new2(f, rb_int_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
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
}
@@ -2226,37 +2234,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 (INT_ZERO_P(f) || FIX2INT(n) >= 0)
- return rb_rational_new1(rb_int_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 = rb_int_mul(TWO, f);
- den = rb_int_lshift(ONE, rb_int_minus(ONE, n));
-
- a = rb_rational_new2(rb_int_minus(two_times_f, ONE), den);
- b = rb_rational_new2(rb_int_plus(two_times_f, ONE), den);
- }
-#else
- {
- VALUE radix_times_f, den;
+ VALUE radix_times_f;
radix_times_f = rb_int_mul(INT2FIX(FLT_RADIX), f);
- den = rb_int_pow(INT2FIX(FLT_RADIX), rb_int_minus(ONE, n));
+#if FLT_RADIX == 2 && 0
+ den = rb_int_lshift(ONE, INT2FIX(1-n));
+#else
+ den = rb_int_positive_pow(FLT_RADIX, 1-n);
+#endif
- a = rb_rational_new2(rb_int_minus(radix_times_f, INT2FIX(FLT_RADIX - 1)), den);
- b = rb_rational_new2(rb_int_plus(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 (nurat_eqeq_p(a, b))
+ if (f_eqeq_p(a, b))
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);
}
@@ -2279,20 +2282,20 @@ static VALUE
float_rationalize(int argc, VALUE *argv, VALUE self)
{
double d = RFLOAT_VALUE(self);
-
- if (d < 0.0)
- return rb_rational_uminus(float_rationalize(argc, argv, DBL2NUM(-d)));
+ VALUE rat;
+ int neg = d < 0.0;
+ if (neg) self = DBL2NUM(-d);
if (rb_check_arity(argc, 0, 1)) {
- return rb_flt_rationalize_with_prec(self, argv[0]);
+ 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)
{
@@ -2305,8 +2308,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;
}
@@ -2321,11 +2324,11 @@ static VALUE
negate_num(VALUE num)
{
if (FIXNUM_P(num)) {
- return rb_int_uminus(num);
+ return rb_int_uminus(num);
}
else {
- BIGNUM_NEGATE(num);
- return rb_big_norm(num);
+ BIGNUM_NEGATE(num);
+ return rb_big_norm(num);
}
}
@@ -2339,51 +2342,51 @@ read_num(const char **s, const char *const end, VALUE *num, VALUE *nexp)
*nexp = ZERO;
*num = ZERO;
if (*s < end && **s != '.') {
- n = rb_int_parse_cstr(*s, end-*s, &e, NULL,
- 10, RB_INT_PARSE_UNDERSCORE);
- if (NIL_P(n))
- return 0;
- *s = e;
- *num = n;
- ok = 1;
+ n = rb_int_parse_cstr(*s, end-*s, &e, NULL,
+ 10, RB_INT_PARSE_UNDERSCORE);
+ if (NIL_P(n))
+ return 0;
+ *s = e;
+ *num = n;
+ ok = 1;
}
if (*s < end && **s == '.') {
- size_t count = 0;
-
- (*s)++;
- fp = rb_int_parse_cstr(*s, end-*s, &e, &count,
- 10, RB_INT_PARSE_UNDERSCORE);
- if (NIL_P(fp))
- return 1;
- *s = e;
- {
+ size_t count = 0;
+
+ (*s)++;
+ fp = rb_int_parse_cstr(*s, end-*s, &e, &count,
+ 10, RB_INT_PARSE_UNDERSCORE);
+ if (NIL_P(fp))
+ return 1;
+ *s = e;
+ {
VALUE l = f_expt10(*nexp = SIZET2NUM(count));
- n = n == ZERO ? fp : rb_int_plus(rb_int_mul(*num, l), fp);
- *num = n;
- fn = SIZET2NUM(count);
- }
- ok = 1;
+ n = n == ZERO ? fp : rb_int_plus(rb_int_mul(*num, l), fp);
+ *num = n;
+ fn = SIZET2NUM(count);
+ }
+ ok = 1;
}
if (ok && *s + 1 < end && islettere(**s)) {
- (*s)++;
- expsign = read_sign(s, end);
- exp = rb_int_parse_cstr(*s, end-*s, &e, NULL,
- 10, RB_INT_PARSE_UNDERSCORE);
- if (NIL_P(exp))
- return 1;
- *s = e;
- if (exp != ZERO) {
- if (expsign == '-') {
- if (fn != ZERO) exp = rb_int_plus(exp, fn);
- }
- else {
- if (fn != ZERO) exp = rb_int_minus(exp, fn);
+ (*s)++;
+ expsign = read_sign(s, end);
+ exp = rb_int_parse_cstr(*s, end-*s, &e, NULL,
+ 10, RB_INT_PARSE_UNDERSCORE);
+ if (NIL_P(exp))
+ return 1;
+ *s = e;
+ if (exp != ZERO) {
+ if (expsign == '-') {
+ if (fn != ZERO) exp = rb_int_plus(exp, fn);
+ }
+ else {
+ if (fn != ZERO) exp = rb_int_minus(exp, fn);
exp = negate_num(exp);
- }
+ }
*nexp = exp;
- }
+ }
}
return ok;
@@ -2393,7 +2396,7 @@ inline static const char *
skip_ws(const char *s, const char *e)
{
while (s < e && isspace((unsigned char)*s))
- ++s;
+ ++s;
return s;
}
@@ -2407,63 +2410,64 @@ 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 canonicalization ? ZERO : 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) {
if (INT_NEGATIVE_P(nexp)) {
VALUE mul;
- if (!FIXNUM_P(nexp)) {
- overflow:
- return sign == '-' ? DBL2NUM(-HUGE_VAL) : DBL2NUM(HUGE_VAL);
+ if (FIXNUM_P(nexp)) {
+ mul = f_expt10(LONG2NUM(-FIX2LONG(nexp)));
+ if (! RB_FLOAT_TYPE_P(mul)) {
+ num = rb_int_mul(num, mul);
+ goto reduce;
+ }
}
- mul = f_expt10(LONG2NUM(-FIX2LONG(nexp)));
- if (RB_FLOAT_TYPE_P(mul)) goto overflow;
- num = rb_int_mul(num, mul);
+ return sign == '-' ? DBL2NUM(-HUGE_VAL) : DBL2NUM(HUGE_VAL);
}
else {
VALUE div;
- if (!FIXNUM_P(nexp)) {
- underflow:
- return sign == '-' ? DBL2NUM(-0.0) : DBL2NUM(+0.0);
+ if (FIXNUM_P(nexp)) {
+ div = f_expt10(nexp);
+ if (! RB_FLOAT_TYPE_P(div)) {
+ den = rb_int_mul(den, div);
+ goto reduce;
+ }
}
- div = f_expt10(nexp);
- if (RB_FLOAT_TYPE_P(div)) goto underflow;
- den = rb_int_mul(den, div);
+ return sign == '-' ? DBL2NUM(-0.0) : DBL2NUM(+0.0);
}
+ reduce:
nurat_reduce(&num, &den);
}
if (sign == '-') {
- num = negate_num(num);
+ num = negate_num(num);
}
- if (!canonicalization || den != ONE)
- num = rb_rational_raw(num, den);
- return num;
+ return rb_rational_raw(num, den);
}
static VALUE
@@ -2489,31 +2493,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)
+ *
+ * NOTE: <tt>'0.3'.to_r</tt> is equivalent to <tt>3/10r</tt>,
+ * but is different from <tt>0.3.to_r</tt>:
*
- * See also Kernel#Rational.
+ * '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)
@@ -2525,7 +2530,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;
}
@@ -2537,7 +2542,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;
}
@@ -2553,6 +2558,8 @@ nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise)
VALUE a1 = numv, a2 = denv;
int state;
+ 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");
@@ -2568,29 +2575,55 @@ nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise)
a2 = RCOMPLEX(a2)->real;
}
- if (RB_FLOAT_TYPE_P(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, 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_FLOAT_TYPE_P(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, 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;
+ }
+ }
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 (!k_integer_p(a1)) {
+ if (UNDEF_P(a2)) {
+ if (!RB_INTEGER_TYPE_P(a1)) {
if (!raise) {
VALUE result = rb_protect(to_rational, a1, NULL);
rb_set_errinfo(Qnil);
@@ -2625,25 +2658,32 @@ nurat_convert(VALUE klass, VALUE numv, VALUE denv, int raise)
}
}
if ((k_numeric_p(a1) && k_numeric_p(a2)) &&
- (!f_integer_p(a1) || !f_integer_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);
+ }
}
- {
- int argc;
- VALUE argv2[2];
- argv2[0] = a1;
- if (a2 == Qundef) {
- argv2[1] = Qnil;
- argc = 1;
- }
- else {
- if (!k_integer_p(a2) && !raise) return Qnil;
- argv2[1] = a2;
- argc = 2;
- }
- return nurat_s_new(argc, argv2, klass);
+ 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);
+ }
+
+
+ return nurat_s_canonicalize_internal(klass, a1, a2);
}
static VALUE
@@ -2663,13 +2703,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)
*
@@ -2704,14 +2750,10 @@ void
Init_Rational(void)
{
VALUE compat;
-#undef rb_intern
-#define rb_intern(str) rb_intern_const(str)
-
- id_abs = rb_intern("abs");
- id_idiv = rb_intern("div");
- id_integer_p = rb_intern("integer?");
- 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);
@@ -2727,10 +2769,10 @@ Init_Rational(void)
rb_define_method(rb_cRational, "-@", rb_rational_uminus, 0);
rb_define_method(rb_cRational, "+", rb_rational_plus, 1);
- rb_define_method(rb_cRational, "-", nurat_sub, 1);
+ rb_define_method(rb_cRational, "-", rb_rational_minus, 1);
rb_define_method(rb_cRational, "*", rb_rational_mul, 1);
- rb_define_method(rb_cRational, "/", nurat_div, 1);
- rb_define_method(rb_cRational, "quo", nurat_div, 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, "**", nurat_expt, 1);
@@ -2764,8 +2806,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);
@@ -2774,14 +2814,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);
generated by cgit v1.2.3 (git 2.25.1) at 2026-01-19 21:24:55 +0000