script_core 0.2.3 → 0.3.0

data/ext/enterprise_script_service/mruby/mrbgems/mruby-random/test/random.rb

@@ -32,8 +32,8 @@
 end
 
 assert("return class of Kernel.rand") do
-  assert_kind_of(Fixnum, rand(3))
-  assert_kind_of(Fixnum, rand(1.5))
+  assert_kind_of(Integer, rand(3))
+  assert_kind_of(Integer, rand(1.5))
   assert_kind_of(Float, rand)
   assert_kind_of(Float, rand(0.5))
 end

data/ext/enterprise_script_service/mruby/mrbgems/mruby-range-ext/mrblib/range.rb

@@ -11,6 +11,7 @@ class Range
   #   (10..20).first(3)  #=> [10, 11, 12]
   #
   def first(*args)
+    raise RangeError, "cannot get the first element of beginless range" if self.begin.nil?
     return self.begin if args.empty?
 
     raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1)" unless args.length == 1
@@ -26,14 +27,42 @@ def first(*args)
     ary
   end
 
+  ##
+  # call-seq:
+  #    rng.last    -> obj
+  #    rng.last(n) -> an_array
+  #
+  # Returns the last object in the range,
+  # or an array of the last +n+ elements.
+  #
+  # Note that with no arguments +last+ will return the object that defines
+  # the end of the range even if #exclude_end? is +true+.
+  #
+  #   (10..20).last      #=> 20
+  #   (10...20).last     #=> 20
+  #   (10..20).last(3)   #=> [18, 19, 20]
+  #   (10...20).last(3)  #=> [17, 18, 19]
+  def last(*args)
+    raise RangeError, "cannot get the last element of endless range" if self.end.nil?
+    return self.end if args.empty?
+
+    raise ArgumentError, "wrong number of arguments (given #{args.length}, expected 1)" unless args.length == 1
+    nv = args[0]
+    n = nv.__to_int
+    raise ArgumentError, "negative array size (or size too big)" unless 0 <= n
+    return self.to_a.last(nv)
+  end
+
   def max(&block)
-    val = self.first
-    last = self.last
+    val = self.begin
+    last = self.end
     return super if block
 
+    raise RangeError, "cannot get the maximum of endless range" if last.nil?
+
     # fast path for numerics
     if val.kind_of?(Numeric) && last.kind_of?(Numeric)
-      raise TypeError if exclude_end? && !last.kind_of?(Fixnum)
+      raise TypeError if exclude_end? && !last.kind_of?(Integer)
       return nil if val > last
       return nil if val == last && exclude_end?
 
@@ -47,9 +76,13 @@ def max(&block)
   end
 
   def min(&block)
-    val = self.first
-    last = self.last
-    return super if block
+    val = self.begin
+    last = self.end
+    if block
+      raise RangeError, "cannot get the minimum of endless range with custom comparison method" if last.nil?
+      return super
+    end
+    return val if last.nil?
 
     # fast path for numerics
     if val.kind_of?(Numeric) && last.kind_of?(Numeric)

data/ext/enterprise_script_service/mruby/mrbgems/mruby-range-ext/src/range.c

@@ -34,16 +34,17 @@ r_lt(mrb_state *mrb, mrb_value a, mrb_value b)
 static mrb_value
 range_cover(mrb_state *mrb, mrb_value range)
 {
-  mrb_value val;
   struct RRange *r = mrb_range_ptr(mrb, range);
+  mrb_value val = mrb_get_arg1(mrb);
   mrb_value beg, end;
 
-  mrb_get_args(mrb, "o", &val);
-
   beg = RANGE_BEG(r);
   end = RANGE_END(r);
 
   if (r_le(mrb, beg, val)) {
+    if (mrb_nil_p(end)) {
+      return mrb_true_value();
+    }
     if (RANGE_EXCL(r)) {
       if (r_lt(mrb, val, end))
         return mrb_true_value();
@@ -57,36 +58,6 @@ range_cover(mrb_state *mrb, mrb_value range)
   return mrb_false_value();
 }
 
-/*
- *  call-seq:
- *     rng.last    -> obj
- *     rng.last(n) -> an_array
- *
- *  Returns the last object in the range,
- *  or an array of the last +n+ elements.
- *
- *  Note that with no arguments +last+ will return the object that defines
- *  the end of the range even if #exclude_end? is +true+.
- *
- *    (10..20).last      #=> 20
- *    (10...20).last     #=> 20
- *    (10..20).last(3)   #=> [18, 19, 20]
- *    (10...20).last(3)  #=> [17, 18, 19]
- */
-static mrb_value
-range_last(mrb_state *mrb, mrb_value range)
-{
-  mrb_value num;
-  mrb_value array;
-
-  if (mrb_get_args(mrb, "|o", &num) == 0) {
-    return mrb_range_end(mrb, range);
-  }
-
-  array = mrb_funcall(mrb, range, "to_a", 0);
-  return mrb_funcall(mrb, array, "last", 1, mrb_to_int(mrb, num));
-}
-
 /*
  *  call-seq:
  *     rng.size                   -> num
@@ -98,7 +69,7 @@ range_last(mrb_state *mrb, mrb_value range)
  *    ('a'..'z').size  #=> nil
  */
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static mrb_value
 range_size(mrb_state *mrb, mrb_value range)
 {
@@ -110,9 +81,13 @@ range_size(mrb_state *mrb, mrb_value range)
 
   beg = RANGE_BEG(r);
   end = RANGE_END(r);
+  if ((mrb_fixnum_p(beg) || mrb_float_p(beg)) && mrb_nil_p(end)) {
+    return mrb_float_value(mrb, INFINITY);
+  }
+
   excl = RANGE_EXCL(r);
-  if (mrb_fixnum_p(beg)) {
-    beg_f = (mrb_float)mrb_fixnum(beg);
+  if (mrb_integer_p(beg)) {
+    beg_f = (mrb_float)mrb_integer(beg);
   }
   else if (mrb_float_p(beg)) {
     beg_f = mrb_float(beg);
@@ -120,8 +95,8 @@ range_size(mrb_state *mrb, mrb_value range)
   else {
     num_p = FALSE;
   }
-  if (mrb_fixnum_p(end)) {
-    end_f = (mrb_float)mrb_fixnum(end);
+  if (mrb_integer_p(end)) {
+    end_f = (mrb_float)mrb_integer(end);
   }
   else if (mrb_float_p(end)) {
     end_f = mrb_float(end);
@@ -161,18 +136,22 @@ range_size(mrb_state *mrb, mrb_value range)
 
   beg = RANGE_BEG(r);
   end = RANGE_END(r);
+  if (mrb_fixnum_p(beg) && mrb_nil_p(end)) {
+    return mrb_nil_value();
+  }
+
   excl = RANGE_EXCL(r) ? 0 : 1;
 
-  if (mrb_fixnum_p(beg) && mrb_fixnum_p(end)) {
-    mrb_int a = mrb_fixnum(beg);
-    mrb_int b = mrb_fixnum(end);
+  if (mrb_integer_p(beg) && mrb_integer_p(end)) {
+    mrb_int a = mrb_integer(beg);
+    mrb_int b = mrb_integer(end);
     mrb_int c = b - a + excl;
 
     return mrb_fixnum_value(c);
   }
   return mrb_nil_value();
 }
-#endif /* MRB_WITHOUT_FLOAT */
+#endif /* MRB_NO_FLOAT */
 
 void
 mrb_mruby_range_ext_gem_init(mrb_state* mrb)
@@ -180,7 +159,6 @@ mrb_mruby_range_ext_gem_init(mrb_state* mrb)
   struct RClass * s = mrb_class_get(mrb, "Range");
 
   mrb_define_method(mrb, s, "cover?", range_cover, MRB_ARGS_REQ(1));
-  mrb_define_method(mrb, s, "last",   range_last,  MRB_ARGS_OPT(1));
   mrb_define_method(mrb, s, "size",   range_size,  MRB_ARGS_NONE());
 }
 

data/ext/enterprise_script_service/mruby/mrbgems/mruby-range-ext/test/range.rb

@@ -5,11 +5,17 @@
   assert_true ("a".."z").cover?("c")
   assert_true !("a".."z").cover?("5")
   assert_true ("a".."z").cover?("cc")
+  assert_true ("a"..).cover?("c")
+  assert_false ("a"..).cover?("5")
+  assert_true ("a"..).cover?("cc")
 end
 
 assert('Range#first') do
   assert_equal 10, (10..20).first
   assert_equal [10, 11, 12], (10..20).first(3)
+  assert_equal 10, (10..).first
+  assert_equal [10, 11, 12], (10..).first(3)
+  assert_raise(RangeError) { (..1).first }
 
   skip unless Object.const_defined?(:Float)
   assert_equal [0, 1, 2], (0..Float::INFINITY).first(3)
@@ -18,6 +24,8 @@
 assert('Range#last') do
   assert_equal 20, (10..20).last
   assert_equal 20, (10...20).last
+  assert_raise(RangeError) { (10..).last }
+  assert_raise(RangeError) { (10...).last }
   assert_equal [18, 19, 20], (10..20).last(3)
   assert_equal [17, 18, 19], (10...20).last(3)
 end
@@ -26,6 +34,9 @@
   assert_equal 42, (1..42).size
   assert_equal 41, (1...42).size
   assert_nil ('a'..'z').size
+  assert_nil ('a'..).size
+
+  assert_nil (1..).size unless Object.const_defined?(:Float)
 
   skip unless Object.const_defined?(:Float)
   assert_equal 6, (1...6.3).size
@@ -33,6 +44,10 @@
   assert_equal 5, (1.1...6).size
   assert_equal 15, (1.0..15.9).size
   assert_equal Float::INFINITY, (0..Float::INFINITY).size
+
+  assert_equal Float::INFINITY, (1..).size
+  assert_equal Float::INFINITY, (1...).size
+  assert_equal Float::INFINITY, (1.0..).size
 end
 
 assert('Range#max') do
@@ -50,6 +65,10 @@
   # returns the endpoint when the endpoint equals the start point and the range is inclusive
   assert_equal 5, (5..5).max
 
+  # raises RangeError when called on an endless range
+  assert_raise(RangeError) { (10..).max }
+  assert_raise(RangeError) { (10...).max }
+
   skip unless Object.const_defined?(:Float)
 
   # returns the maximum value in the Float range when called with no arguments
@@ -94,26 +113,31 @@
   # returns the minimum value in the range when called with no arguments
   assert_equal 1, (1..10).min
   assert_equal 1, (1...10).min
+  assert_equal 1, (1..).min
 
   # returns nil when the start point is greater than the endpoint
   assert_equal nil, (100..10).min
 
   # returns nil when the endpoint equals the start point and the range is exclusive
-  assert_equal nil, (5...5).max
+  assert_equal nil, (5...5).min
 
   # returns the endpoint when the endpoint equals the start point and the range is inclusive
-  assert_equal 5, (5..5).max
+  assert_equal 5, (5..5).min
 
   skip unless Object.const_defined?(:Float)
 
   # returns the minimum value in the Float range when called with no arguments
   assert_equal 303.20, (303.20..908.1111).min
+  assert_equal 1, (1.0..).min
 
   # returns nil when the start point is greater than the endpoint in a Float range
-  assert_equal nil, (3003.20..908.1111).max
+  assert_equal nil, (3003.20..908.1111).min
 end
 
 assert('Range#min given a block') do
+  # raise when called with a block in endless range
+  assert_raise(RangeError) { (1..).min{} }
+
   # passes each pair of values in the range to the block
   acc = []
   (1..10).min do |a, b|

data/ext/enterprise_script_service/mruby/mrbgems/mruby-rational/mrblib/rational.rb

@@ -47,12 +47,14 @@ def /(rhs)
     end
   end
 
+  alias quo /
+
   def <=>(rhs)
-    if rhs.is_a?(Integral)
+    case rhs
+    when Integer, Float
       return numerator <=> rhs if denominator == 1
       rhs = Rational(rhs)
     end
-
     case rhs
     when Rational
       (numerator * rhs.denominator - denominator * rhs.numerator) <=> 0
@@ -65,14 +67,13 @@ def <=>(rhs)
 
   def ==(rhs)
     return true if self.equal?(rhs)
-    if rhs.is_a?(Integral) && denominator == 1
-      return numerator == rhs
-    end
-    if rhs.is_a?(Rational)
-      numerator * rhs.denominator == denominator * rhs.numerator
-    else
-      rhs == self
+    case rhs
+    when Integer, Float
+      return numerator == rhs if denominator == 1
+    when Rational
+      return numerator * rhs.denominator == denominator * rhs.numerator
     end
+    rhs == self
   end
 end
 
@@ -83,16 +84,9 @@ def to_r
 end
 
 module Kernel
-  def Rational(numerator, denominator = 1)
-    a = numerator
-    b = denominator
-    a, b = b, a % b until b == 0
-    Rational._new(numerator.div(a), denominator.div(a))
-  end
-
   [:+, :-, :*, :/, :<=>, :==, :<, :<=, :>, :>=].each do |op|
-    Fixnum.instance_eval do
-      original_operator_name = "__original_operator_#{op}_rational"
+    original_operator_name = :"__original_operator_#{op}_rational"
+    Integer.instance_eval do
       alias_method original_operator_name, op
       define_method op do |rhs|
         if rhs.is_a? Rational
@@ -103,7 +97,6 @@ def Rational(numerator, denominator = 1)
       end
     end
     Float.instance_eval do
-      original_operator_name = "__original_operator_#{op}_rational"
       alias_method original_operator_name, op
       define_method op do |rhs|
         if rhs.is_a? Rational
@@ -114,4 +107,3 @@ def Rational(numerator, denominator = 1)
     end if Object.const_defined?(:Float)
   end
 end
-

data/ext/enterprise_script_service/mruby/mrbgems/mruby-rational/src/rational.c

@@ -2,6 +2,7 @@
 #include <mruby/class.h>
 #include <mruby/string.h>
 #include <mruby/numeric.h>
+#include <mruby/presym.h>
 
 struct mrb_rational {
   mrb_int numerator;
@@ -60,88 +61,243 @@ static mrb_value
 rational_numerator(mrb_state *mrb, mrb_value self)
 {
   struct mrb_rational *p = rational_ptr(mrb, self);
-  return mrb_fixnum_value(p->numerator);
+  return mrb_int_value(mrb, p->numerator);
 }
 
 static mrb_value
 rational_denominator(mrb_state *mrb, mrb_value self)
 {
   struct mrb_rational *p = rational_ptr(mrb, self);
-  return mrb_fixnum_value(p->denominator);
+  return mrb_int_value(mrb, p->denominator);
+}
+
+static void
+rat_overflow(mrb_state *mrb)
+{
+  mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in rational");
+}
+
+static void
+rat_zerodiv(mrb_state *mrb)
+{
+  mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0 in rational");
 }
 
 static mrb_value
 rational_new(mrb_state *mrb, mrb_int numerator, mrb_int denominator)
 {
-  struct RClass *c = mrb_class_get(mrb, "Rational");
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Rational));
   struct mrb_rational *p;
-  struct RBasic *rat = rational_alloc(mrb, c, &p);
+  struct RBasic *rat;
+
+  if (denominator == 0) {
+    rat_zerodiv(mrb);
+  }
+  if (denominator < 0) {
+    if (numerator == MRB_INT_MIN || denominator == MRB_INT_MIN) {
+      rat_overflow(mrb);
+    }
+    numerator *= -1;
+    denominator *= -1;
+  }
+  rat = rational_alloc(mrb, c, &p);
   p->numerator = numerator;
   p->denominator = denominator;
   MRB_SET_FROZEN_FLAG(rat);
   return mrb_obj_value(rat);
 }
 
+inline static mrb_int
+i_gcd(mrb_int x, mrb_int y)
+{
+  mrb_uint u, v, t;
+  int shift;
+
+  if (x < 0)
+    x = -x;
+  if (y < 0)
+    y = -y;
+
+  if (x == 0)
+    return y;
+  if (y == 0)
+    return x;
+
+  u = (mrb_uint)x;
+  v = (mrb_uint)y;
+  for (shift = 0; ((u | v) & 1) == 0; ++shift) {
+    u >>= 1;
+    v >>= 1;
+  }
+
+  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 (mrb_int)(u << shift);
+}
+
+static mrb_value
+rational_new_i(mrb_state *mrb, mrb_int n, mrb_int d)
+{
+  mrb_int a;
+
+  if (d == 0) {
+    rat_zerodiv(mrb);
+  }
+  a = i_gcd(n, d);
+  if ((n == MRB_INT_MIN || d == MRB_INT_MIN) && a == -1) {
+    rat_overflow(mrb);
+  }
+  return rational_new(mrb, n/a, d/a);
+}
+
+#ifndef MRB_NO_FLOAT
+#include <math.h>
+
+#if defined(MRB_INT32) || defined(MRB_USE_FLOAT32)
+#define frexp_rat(x,exp) frexpf((float)x, exp)
+#define ldexp_rat(x,exp) ldexpf((float)x, exp)
+#define RAT_MANT_DIG FLT_MANT_DIG
+#define RAT_INT_LIMIT 30
+#define RAT_HUGE_VAL HUGE_VALF
+#else
+#define frexp_rat frexp
+#define ldexp_rat ldexp
+#define RAT_MANT_DIG DBL_MANT_DIG
+#define RAT_INT_LIMIT 62
+#define RAT_HUGE_VAL HUGE_VAL
+#endif
+
+static void
+float_decode_internal(mrb_state *mrb, mrb_float f, mrb_float *rf, int *n)
+{
+  f = (mrb_float)frexp_rat(f, n);
+  if (isinf(f)) rat_overflow(mrb);
+  f = (mrb_float)ldexp_rat(f, RAT_MANT_DIG);
+  *n -= RAT_MANT_DIG;
+  *rf = f;
+}
+
+void mrb_check_num_exact(mrb_state *mrb, mrb_float num);
+
+static mrb_value
+rational_new_f(mrb_state *mrb, mrb_float f0)
+{
+  mrb_float f;
+  int n;
+
+  mrb_check_num_exact(mrb, f0);
+  float_decode_internal(mrb, f0, &f, &n);
+#if FLT_RADIX == 2
+  if (n == 0)
+    return rational_new(mrb, (mrb_int)f, 1);
+  if (n > 0) {
+    f = ldexp_rat(f, n);
+    if (f == RAT_HUGE_VAL || f > (mrb_float)MRB_INT_MAX) {
+      rat_overflow(mrb);
+    }
+    return rational_new(mrb, (mrb_uint)f, 1);
+  }
+  if (n < -RAT_INT_LIMIT) {
+    f = ldexp_rat(f, n+RAT_INT_LIMIT);
+    n = RAT_INT_LIMIT;
+  }
+  else {
+    n = -n;
+  }
+  return rational_new_i(mrb, (mrb_int)f, ((mrb_int)1)<<n);
+#else
+  mrb_int pow = 1;
+  if (n < 0) {
+    n = -n;
+    while (n > RAT_INT_LIMIT) {
+      f /= 2;
+      n--;
+    }
+    while (n--) {
+      pow *= FLT_RADIX;
+    }
+    return rational_new_i(mrb, f, pow);
+  }
+  else {
+    while (n--) {
+      if (MRB_INT_MAX/FLT_RADIX < pow) {
+        rat_overflow(mrb);
+      }
+      pow *= FLT_RADIX;
+    }
+    return rational_new(mrb, (mrb_int)f*pow, 1);
+  }
+#endif
+}
+#endif
+
 static mrb_value
 rational_s_new(mrb_state *mrb, mrb_value self)
 {
   mrb_int numerator, denominator;
 
-#ifdef MRB_WITHOUT_FLOAT
+#ifdef MRB_NO_FLOAT
   mrb_get_args(mrb, "ii", &numerator, &denominator);
 #else
 
-#define DROP_PRECISION(cond, num, denom) \
-  do { \
-      while (cond) { \
-        num /= 2; \
-        denom /= 2; \
-      } \
-  } while (0)
-
-  mrb_value numv, denomv;
+ mrb_value numv, denomv;
 
   mrb_get_args(mrb, "oo", &numv, &denomv);
-  if (mrb_fixnum_p(numv)) {
-    numerator = mrb_fixnum(numv);
+  if (mrb_integer_p(numv)) {
+    numerator = mrb_integer(numv);
 
-    if (mrb_fixnum_p(denomv)) {
-      denominator = mrb_fixnum(denomv);
+    if (mrb_integer_p(denomv)) {
+      denominator = mrb_integer(denomv);
     }
     else {
+      mrb_float numf = (mrb_float)numerator;
       mrb_float denomf = mrb_to_flo(mrb, denomv);
 
-      DROP_PRECISION(denomf < MRB_INT_MIN || denomf > MRB_INT_MAX, numerator, denomf);
-      denominator = denomf;
+      return rational_new_f(mrb, numf/denomf);
     }
   }
   else {
     mrb_float numf = mrb_to_flo(mrb, numv);
+    mrb_float denomf;
 
-    if (mrb_fixnum_p(denomv)) {
-      denominator = mrb_fixnum(denomv);
+    if (mrb_integer_p(denomv)) {
+      denomf = (mrb_float)mrb_integer(denomv);
     }
     else {
-      mrb_float denomf = mrb_to_flo(mrb, denomv);
-
-      DROP_PRECISION(denomf < MRB_INT_MIN || denomf > MRB_INT_MAX, numf, denomf);
-      denominator = denomf;
+      denomf = mrb_to_flo(mrb, denomv);
     }
-
-    DROP_PRECISION(numf < MRB_INT_MIN || numf > MRB_INT_MAX, numf, denominator);
-    numerator = numf;
+    return rational_new_f(mrb, numf/denomf);
   }
 #endif
-
   return rational_new(mrb, numerator, denominator);
 }
 
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
 static mrb_value
 rational_to_f(mrb_state *mrb, mrb_value self)
 {
   struct mrb_rational *p = rational_ptr(mrb, self);
-  mrb_float f = (mrb_float)p->numerator / (mrb_float)p->denominator;
+  mrb_float f;
+
+  if (p->denominator == 0.0) {
+    f = INFINITY;
+  }
+  else {
+    f = (mrb_float)p->numerator / (mrb_float)p->denominator;
+  }
 
   return mrb_float_value(mrb, f);
 }
@@ -152,9 +308,9 @@ rational_to_i(mrb_state *mrb, mrb_value self)
 {
   struct mrb_rational *p = rational_ptr(mrb, self);
   if (p->denominator == 0) {
-    mrb_raise(mrb, mrb_exc_get(mrb, "StandardError"), "divided by 0");
+    rat_zerodiv(mrb);
   }
-  return mrb_fixnum_value(p->numerator / p->denominator);
+  return mrb_int_value(mrb, p->numerator / p->denominator);
 }
 
 static mrb_value
@@ -176,14 +332,35 @@ rational_negative_p(mrb_state *mrb, mrb_value self)
 static mrb_value
 fix_to_r(mrb_state *mrb, mrb_value self)
 {
-  return rational_new(mrb, mrb_fixnum(self), 1);
+  return rational_new(mrb, mrb_integer(self), 1);
+}
+
+static mrb_value
+rational_m(mrb_state *mrb, mrb_value self)
+{
+#ifdef MRB_NO_FLOAT
+  mrb_int n, d = 1;
+  mrb_get_args(mrb, "i|i", &n, &d);
+  return rational_new_i(mrb, n, d);
+#else
+  mrb_value a, b = mrb_fixnum_value(1);
+  mrb_get_args(mrb, "o|o", &a, &b);
+  if (mrb_integer_p(a) && mrb_integer_p(b)) {
+    return rational_new_i(mrb, mrb_integer(a), mrb_integer(b));
+  }
+  else {
+    mrb_float x = mrb_to_flo(mrb, a);
+    mrb_float y = mrb_to_flo(mrb, b);
+    return rational_new_f(mrb, x/y);
+  }
+#endif
 }
 
 void mrb_mruby_rational_gem_init(mrb_state *mrb)
 {
   struct RClass *rat;
 
-  rat = mrb_define_class(mrb, "Rational", mrb_class_get(mrb, "Numeric"));
+  rat = mrb_define_class_id(mrb, MRB_SYM(Rational), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
 #ifdef RATIONAL_USE_ISTRUCT
   MRB_SET_INSTANCE_TT(rat, MRB_TT_ISTRUCT);
   mrb_assert(sizeof(struct mrb_rational) < ISTRUCT_DATA_SIZE);
@@ -194,13 +371,14 @@ void mrb_mruby_rational_gem_init(mrb_state *mrb)
   mrb_define_class_method(mrb, rat, "_new", rational_s_new, MRB_ARGS_REQ(2));
   mrb_define_method(mrb, rat, "numerator", rational_numerator, MRB_ARGS_NONE());
   mrb_define_method(mrb, rat, "denominator", rational_denominator, MRB_ARGS_NONE());
-#ifndef MRB_WITHOUT_FLOAT
+#ifndef MRB_NO_FLOAT
   mrb_define_method(mrb, rat, "to_f", rational_to_f, MRB_ARGS_NONE());
 #endif
   mrb_define_method(mrb, rat, "to_i", rational_to_i, MRB_ARGS_NONE());
   mrb_define_method(mrb, rat, "to_r", rational_to_r, MRB_ARGS_NONE());
   mrb_define_method(mrb, rat, "negative?", rational_negative_p, MRB_ARGS_NONE());
-  mrb_define_method(mrb, mrb->fixnum_class, "to_r", fix_to_r, MRB_ARGS_NONE());
+  mrb_define_method(mrb, mrb->integer_class, "to_r", fix_to_r, MRB_ARGS_NONE());
+  mrb_define_method(mrb, mrb->kernel_module, "Rational", rational_m, MRB_ARGS_ARG(1,1));
 }
 
 void