enclave 0.1.0

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

@@ -0,0 +1,1269 @@
+#include <mruby.h>
+#include <mruby/class.h>
+#include <mruby/numeric.h>
+#include <mruby/internal.h>
+#include <mruby/presym.h>
+
+#ifndef MRB_NO_FLOAT
+#include <math.h>
+mrb_value mrb_complex_new(mrb_state *, mrb_float, mrb_float);
+#endif
+mrb_bool mrb_complex_eq(mrb_state *mrb, mrb_value, mrb_value);
+mrb_value mrb_complex_add(mrb_state *mrb, mrb_value, mrb_value);
+mrb_value mrb_complex_sub(mrb_state *mrb, mrb_value, mrb_value);
+mrb_value mrb_complex_mul(mrb_state *mrb, mrb_value, mrb_value);
+mrb_value mrb_complex_div(mrb_state *mrb, mrb_value, mrb_value);
+mrb_value mrb_bint_mul_n(mrb_state *mrb, mrb_value x, mrb_value y);
+void mrb_bint_reduce(mrb_state *mrb, mrb_value *x, mrb_value *y);
+
+#ifdef MRB_USE_BIGINT
+struct mrb_rational {
+  union {
+    struct {
+      mrb_int num;
+      mrb_int den;
+    } i;
+    struct {
+      struct RBasic *num;
+      struct RBasic *den;
+    } b;
+  };
+};
+#define numerator i.num
+#define denominator i.den
+#define RAT_BIGINT 1
+#define RAT_BIGINT_P(obj) (mrb_obj_ptr(obj)->flags & RAT_BIGINT)
+#else
+struct mrb_rational {
+  mrb_int numerator;
+  mrb_int denominator;
+};
+#endif
+
+#define ONE mrb_fixnum_value(1)
+#define ZERO mrb_fixnum_value(0)
+
+#if defined(MRB_INT64) && defined(MRB_32BIT)
+struct RRational {
+  MRB_OBJECT_HEADER;
+  struct mrb_rational *p;
+};
+
+static struct mrb_rational*
+rat_ptr(mrb_state *mrb, mrb_value v)
+{
+  struct RRational *r = (struct RRational*)mrb_obj_ptr(v);
+
+  if (!r->p) {
+    mrb_raise(mrb, E_ARGUMENT_ERROR, "uninitialized rational");
+  }
+  return r->p;
+}
+#else
+#define RATIONAL_INLINE
+struct RRational {
+  MRB_OBJECT_HEADER;
+  struct mrb_rational r;
+};
+#define rat_ptr(mrb, v) (&((struct RRational*)mrb_obj_ptr(v))->r)
+#endif
+
+mrb_static_assert_object_size(struct RRational);
+
+static struct mrb_rational*
+rat_alloc(mrb_state *mrb, struct RClass *c, struct RBasic **obj)
+{
+  struct RRational *s = MRB_OBJ_ALLOC(mrb, MRB_TT_RATIONAL, c);
+  struct mrb_rational *p;
+#ifdef RATIONAL_INLINE
+  p = &s->r;
+#else
+  p = s->p = (struct mrb_rational*)mrb_malloc(mrb, sizeof(struct mrb_rational));
+#endif
+  *obj = (struct RBasic*)s;
+  return p;
+}
+
+#ifdef RAT_BIGINT
+int
+mrb_rational_mark(mrb_state *mrb, struct RBasic *rat)
+{
+  if (!(rat->flags & RAT_BIGINT)) return 0;
+
+  mrb_value self = mrb_obj_value(rat);
+  struct mrb_rational *p = rat_ptr(mrb, self);
+  mrb_gc_mark(mrb, p->b.num);
+  mrb_gc_mark(mrb, p->b.den);
+  return 2;
+}
+#endif
+
+static mrb_value
+rat_numerator(mrb_state *mrb, mrb_value self)
+{
+  struct mrb_rational *p = rat_ptr(mrb, self);
+#ifdef RAT_BIGINT
+  if (RAT_BIGINT_P(self)) {
+    return mrb_obj_value(p->b.num);
+  }
+#endif
+  return mrb_int_value(mrb, p->numerator);
+}
+
+/*
+ * call-seq:
+ *   rational.numerator -> integer
+ *
+ * Returns the numerator of the rational number.
+ *
+ *   Rational(3, 4).numerator  #=> 3
+ *   Rational(-2, 5).numerator #=> -2
+ *   Rational(6, 8).numerator  #=> 3 (reduced form)
+ */
+/* normalized version of rat_numerator() */
+static mrb_value
+rational_numerator(mrb_state *mrb, mrb_value self)
+{
+  mrb_value n = rat_numerator(mrb, self);
+  if (mrb_bigint_p(n)) {
+    /* normalize bigint */
+    return mrb_bint_mul(mrb, n, ONE);
+  }
+  return n;
+}
+
+static mrb_value
+rat_denominator(mrb_state *mrb, mrb_value self)
+{
+  struct mrb_rational *p = rat_ptr(mrb, self);
+#ifdef RAT_BIGINT
+  if (RAT_BIGINT_P(self)) {
+    return mrb_obj_value(p->b.den);
+  }
+#endif
+  return mrb_int_value(mrb, p->denominator);
+}
+
+/*
+ * call-seq:
+ *   rational.denominator -> integer
+ *
+ * Returns the denominator of the rational number.
+ * The denominator is always positive.
+ *
+ *   Rational(3, 4).denominator  #=> 4
+ *   Rational(-2, 5).denominator #=> 5
+ *   Rational(6, 8).denominator  #=> 4 (reduced form)
+ */
+/* normalized version of rat_denominator() */
+static mrb_value
+rational_denominator(mrb_state *mrb, mrb_value self)
+{
+  mrb_value n = rat_denominator(mrb, self);
+  if (mrb_bigint_p(n)) {
+    /* normalize bigint */
+    return mrb_bint_mul(mrb, n, ONE);
+  }
+  return n;
+}
+
+static mrb_noreturn void
+rat_overflow(mrb_state *mrb)
+{
+  mrb_raise(mrb, E_RANGE_ERROR, "integer overflow in rational");
+}
+
+static mrb_noreturn void
+rat_zerodiv(mrb_state *mrb)
+{
+  mrb_raise(mrb, E_ZERODIV_ERROR, "divided by 0 in rational");
+}
+
+static mrb_noreturn void
+rat_type_error(mrb_state *mrb, mrb_value x)
+{
+  mrb_raisef(mrb, E_TYPE_ERROR, "%T cannot be converted to Rational", x);
+}
+
+void
+mrb_rational_copy(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  struct mrb_rational *p1 = rat_ptr(mrb, x);
+  struct mrb_rational *p2 = rat_ptr(mrb, y);
+#ifdef RAT_BIGINT
+ struct RRational *r = (struct RRational*)mrb_obj_ptr(x);
+  if (RAT_BIGINT_P(y)) {
+    p1->b.num = p2->b.num;
+    p1->b.den = p2->b.den;
+    r->flags |= RAT_BIGINT;
+    return;
+  }
+  r->flags &= ~RAT_BIGINT;
+#endif
+  p1->numerator = p2->numerator;
+  p1->denominator = p2->denominator;
+}
+
+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);
+}
+
+#ifdef RAT_BIGINT
+static mrb_value
+rational_new_b(mrb_state *mrb, mrb_value n, mrb_value d)
+{
+  /* bigint check */
+  mrb_assert(mrb_bigint_p(n));
+  d = mrb_as_bint(mrb, d);
+  mrb_int cmp = mrb_bint_cmp(mrb, d, ZERO);
+  if (cmp == 0) {
+    rat_zerodiv(mrb);
+  }
+  /* negative */
+  if (cmp < 0) {
+    n = mrb_bint_neg(mrb, n);
+    d = mrb_bint_neg(mrb, d);
+  }
+  /* normalize (n/gcd, d/gcd) */
+  mrb_bint_reduce(mrb, &n, &d);
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Rational));
+  struct RBasic *rat;
+  struct mrb_rational *p = rat_alloc(mrb, c, &rat);
+  rat->flags |= RAT_BIGINT;
+  p->b.num = (struct RBasic*)mrb_obj_ptr(n);
+  p->b.den = (struct RBasic*)mrb_obj_ptr(d);
+  rat->frozen = 1;
+  return mrb_obj_value(rat);
+}
+#endif
+
+mrb_value
+mrb_rational_new(mrb_state *mrb, mrb_int nume, mrb_int deno)
+{
+  if (deno == 0) {
+    rat_zerodiv(mrb);
+  }
+  if (nume == MRB_INT_MIN || deno == MRB_INT_MIN) {
+#ifdef RAT_BIGINT
+    mrb_value num = mrb_as_bint(mrb, mrb_int_value(mrb, nume));
+    mrb_value den = mrb_as_bint(mrb, mrb_int_value(mrb, deno));
+    return rational_new_b(mrb, num, den);
+#else
+    rat_overflow(mrb);
+#endif
+  }
+  if (deno < 0) {
+    nume *= -1;
+    deno *= -1;
+  }
+
+  mrb_int a = i_gcd(nume, deno);
+  nume /= a;
+  deno /= a;
+
+  struct RClass *c = mrb_class_get_id(mrb, MRB_SYM(Rational));
+  struct RBasic *rat;
+  struct mrb_rational *p = rat_alloc(mrb, c, &rat);
+  p->numerator = nume;
+  p->denominator = deno;
+  rat->frozen = 1;
+  return mrb_obj_value(rat);
+}
+
+#define rational_new_i(mrb,n,d) mrb_rational_new(mrb, n, d)
+
+#ifndef MRB_NO_FLOAT
+
+#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 mrb_value
+rational_new_f(mrb_state *mrb, mrb_float f)
+{
+  mrb_check_num_exact(mrb, f);
+  if (f == 0.0) {
+    return rational_new_i(mrb, 0, 1);
+  }
+  int exp;
+  // Extract mantissa and exponent
+  double mantissa = frexp_rat(f, &exp);
+  const mrb_int precision = ((mrb_int)1) << RAT_MANT_DIG;
+
+  mrb_int nume = (mrb_int)(mantissa * precision);
+  mrb_int deno = precision;
+
+  if (exp > 0) {
+    mrb_int temp;
+    /* Check exp < MRB_INT_BIT-1 to avoid undefined behavior from shifting into sign bit */
+    if (exp >= MRB_INT_BIT - 1 || mrb_int_mul_overflow(nume, ((mrb_int)1)<<exp, &temp)) {
+#ifndef RAT_BIGINT
+      rat_overflow(mrb);
+#else
+      mrb_value n = mrb_bint_lshift(mrb, mrb_bint_new_int(mrb, nume), exp);
+      return rational_new_b(mrb, n, mrb_int_value(mrb, deno));
+#endif
+    }
+    nume = temp;
+  }
+  else if (exp < 0) {
+    /* exp is negative, so we need to multiply denominator by 2^(-exp) */
+    int neg_exp = -exp;
+    if (neg_exp >= MRB_INT_BIT - 1 || mrb_int_mul_overflow(deno, ((mrb_int)1)<<neg_exp, &deno)) {
+#ifndef RAT_BIGINT
+      rat_overflow(mrb);
+#else
+      mrb_value d = mrb_bint_lshift(mrb, mrb_bint_new_int(mrb, deno), neg_exp);
+      return rational_new_b(mrb, mrb_bint_new_int(mrb, nume), d);
+#endif
+    }
+  }
+  return rational_new_i(mrb, nume, deno);
+}
+
+static mrb_float
+rat_float(mrb_state *mrb, mrb_value x)
+{
+  struct mrb_rational *p = rat_ptr(mrb, x);
+
+#ifdef RAT_BIGINT
+  if (RAT_BIGINT_P(x)) {
+    return mrb_bint_as_float(mrb, mrb_obj_value(p->b.num)) / mrb_bint_as_float(mrb, mrb_obj_value(p->b.den));
+  }
+#endif
+  return (mrb_float)p->numerator / (mrb_float)p->denominator;
+}
+
+mrb_value
+mrb_rational_to_f(mrb_state *mrb, mrb_value self)
+{
+  mrb_float f = rat_float(mrb, self);
+  return mrb_float_value(mrb, f);
+}
+#endif
+
+/*
+ * call-seq:
+ *   rational.to_i -> integer
+ *
+ * Returns the rational number truncated to an integer.
+ *
+ *   Rational(3, 4).to_i   #=> 0
+ *   Rational(7, 3).to_i   #=> 2
+ *   Rational(-5, 2).to_i  #=> -2
+ */
+mrb_value
+mrb_rational_to_i(mrb_state *mrb, mrb_value self)
+{
+  struct mrb_rational *p = rat_ptr(mrb, self);
+#ifdef RAT_BIGINT
+  if (RAT_BIGINT_P(self)) {
+    return mrb_bint_div(mrb, mrb_obj_value(p->b.num), mrb_obj_value(p->b.den));
+  }
+#endif
+  return mrb_int_value(mrb, p->numerator / p->denominator);
+}
+
+mrb_value
+mrb_as_rational(mrb_state *mrb, mrb_value x)
+{
+  switch(mrb_type(x)) {
+  case MRB_TT_INTEGER:
+    return rational_new_i(mrb, mrb_integer(x), 1);
+#ifdef RAT_BIGINT
+  case MRB_TT_BIGINT:
+    return rational_new_b(mrb, x, ONE);
+#endif
+  case MRB_TT_RATIONAL:
+    return x;
+#ifndef MRB_NO_FLOAT
+#ifdef MRB_USE_COMPLEX
+  case MRB_TT_COMPLEX:
+#endif
+  case MRB_TT_FLOAT:
+    return rational_new_f(mrb, mrb_as_float(mrb, x));
+#endif
+  default:
+    rat_type_error(mrb, x);
+  }
+}
+
+/*
+ * call-seq:
+ *   rational.negative? -> true or false
+ *
+ * Returns true if the rational number is negative, false otherwise.
+ *
+ *   Rational(-1, 2).negative?  #=> true
+ *   Rational(1, 2).negative?   #=> false
+ *   Rational(0, 1).negative?   #=> false
+ */
+static mrb_value
+rational_negative_p(mrb_state *mrb, mrb_value self)
+{
+  struct mrb_rational *p = rat_ptr(mrb, self);
+#ifdef RAT_BIGINT
+  if (RAT_BIGINT_P(self)) {
+    mrb_int cmp = mrb_bint_cmp(mrb, mrb_obj_value(p->b.num), ZERO);
+    return mrb_bool_value(cmp < 0);
+  }
+#endif
+  return mrb_bool_value(p->numerator < 0);
+}
+
+#ifndef MRB_NO_FLOAT
+/*
+ * call-seq:
+ *   float.to_r -> rational
+ *
+ * Converts the float to a rational number. The conversion preserves
+ * the exact value of the float as a fraction.
+ *
+ *   0.5.to_r    #=> Rational(1, 2)
+ *   0.25.to_r   #=> Rational(1, 4)
+ *   1.5.to_r    #=> Rational(3, 2)
+ */
+static mrb_value
+float_to_r(mrb_state *mrb, mrb_value self)
+{
+  return rational_new_f(mrb, mrb_float(self));
+}
+#endif
+
+/*
+ * call-seq:
+ *   integer.to_r -> rational
+ *
+ * Converts the integer to a rational number with denominator 1.
+ *
+ *   5.to_r     #=> Rational(5, 1)
+ *   (-3).to_r  #=> Rational(-3, 1)
+ *   0.to_r     #=> Rational(0, 1)
+ */
+static mrb_value
+int_to_r(mrb_state *mrb, mrb_value self)
+{
+#ifdef RAT_BIGINT
+  if (mrb_bigint_p(self)) {
+    return rational_new_b(mrb, self, ONE);
+  }
+#endif
+  return rational_new_i(mrb, mrb_integer(self), 1);
+}
+
+/*
+ * call-seq:
+ *   nil.to_r -> rational
+ *
+ * Converts nil to Rational(0, 1).
+ *
+ *   nil.to_r  #=> Rational(0, 1)
+ */
+static mrb_value
+nil_to_r(mrb_state *mrb, mrb_value self)
+{
+  return rational_new_i(mrb, 0, 1);
+}
+
+#if !defined(MRB_NO_FLOAT) || defined(RAT_BIGINT)
+static mrb_value
+rational_new(mrb_state *mrb, mrb_value a, mrb_value b)
+{
+#ifdef MRB_NO_FLOAT
+  a = mrb_as_int(mrb, a);
+  b = mrb_as_int(mrb, b);
+  return rational_new_i(mrb, mrb_integer(a), mrb_integer(b));
+#else
+  if (mrb_integer_p(a) && mrb_integer_p(b)) {
+    return rational_new_i(mrb, mrb_integer(a), mrb_integer(b));
+  }
+#ifdef RAT_BIGINT
+  else if (mrb_bigint_p(a) || mrb_bigint_p(b)) {
+    return rational_new_b(mrb, mrb_as_bint(mrb, a), b);
+  }
+#endif
+  else {
+    mrb_float x = mrb_as_float(mrb, a);
+    mrb_float y = mrb_as_float(mrb, b);
+    return rational_new_f(mrb, x/y);
+  }
+#endif
+}
+
+/*
+ * call-seq:
+ *   Rational(numerator, denominator = 1) -> rational
+ *
+ * Creates a rational number from numerator and denominator.
+ * The rational is automatically reduced to lowest terms.
+ *
+ *   Rational(1, 2)    #=> Rational(1, 2)
+ *   Rational(6, 8)    #=> Rational(3, 4)
+ *   Rational(5)       #=> Rational(5, 1)
+ *   Rational(-2, 4)   #=> Rational(-1, 2)
+ */
+static mrb_value
+rational_m(mrb_state *mrb, mrb_value self)
+{
+  mrb_value a, b = ONE;
+  mrb_get_args(mrb, "o|o", &a, &b);
+  return rational_new(mrb, a, b);
+}
+
+#else
+
+/*
+ * call-seq:
+ *   Rational(numerator, denominator = 1) -> rational
+ *
+ * Creates a rational number from numerator and denominator.
+ * The rational is automatically reduced to lowest terms.
+ *
+ *   Rational(1, 2)    #=> Rational(1, 2)
+ *   Rational(6, 8)    #=> Rational(3, 4)
+ *   Rational(5)       #=> Rational(5, 1)
+ *   Rational(-2, 4)   #=> Rational(-1, 2)
+ */
+static mrb_value
+rational_m(mrb_state *mrb, mrb_value self)
+{
+  mrb_int n, d = 1;
+  mrb_get_args(mrb, "i|i", &n, &d);
+  return rational_new_i(mrb, n, d);
+}
+#endif
+
+static mrb_value
+rational_eq_b(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  struct mrb_rational *p1 = rat_ptr(mrb, x);
+  mrb_bool result;
+
+  switch (mrb_type(y)) {
+  case MRB_TT_INTEGER:
+    {
+      /* For bigint-backed rationals, check if denominator is 1 */
+      mrb_value den = mrb_obj_value(p1->b.den);
+      mrb_int den_cmp = mrb_bint_cmp(mrb, den, mrb_int_value(mrb, 1));
+      if (den_cmp != 0) return mrb_false_value();
+      mrb_value num = mrb_obj_value(p1->b.num);
+      result = mrb_bint_cmp(mrb, num, y) == 0;
+      break;
+    }
+#ifdef MRB_USE_BIGINT
+  case MRB_TT_BIGINT:
+    {
+      /* For bigint-backed rationals comparing with bigint */
+      mrb_value den = mrb_obj_value(p1->b.den);
+      mrb_int den_cmp = mrb_bint_cmp(mrb, den, mrb_int_value(mrb, 1));
+      if (den_cmp != 0) return mrb_false_value();
+      mrb_value num = mrb_obj_value(p1->b.num);
+      result = mrb_bint_cmp(mrb, num, y) == 0;
+      break;
+    }
+#endif
+#ifndef MRB_NO_FLOAT
+  case MRB_TT_FLOAT:
+    {
+      /* For bigint-backed rationals, convert to float and compare */
+      mrb_float num_f = mrb_bint_as_float(mrb, mrb_obj_value(p1->b.num));
+      mrb_float den_f = mrb_bint_as_float(mrb, mrb_obj_value(p1->b.den));
+      result = (num_f / den_f) == mrb_float(y);
+      break;
+    }
+#endif
+  case MRB_TT_RATIONAL:
+    {
+      /* Compare by converting to float - less precise but safe */
+      mrb_float v1 = mrb_bint_as_float(mrb, mrb_obj_value(p1->b.num)) /
+                     mrb_bint_as_float(mrb, mrb_obj_value(p1->b.den));
+      mrb_float v2 = rat_float(mrb, y);
+      result = v1 == v2;
+      break;
+    }
+
+#ifdef MRB_USE_COMPLEX
+  case MRB_TT_COMPLEX:
+   {
+      result = mrb_complex_eq(mrb, y, mrb_rational_to_f(mrb, x));
+      break;
+    }
+#endif
+  default:
+    result = mrb_equal(mrb, y, x);
+    break;
+  }
+  return mrb_bool_value(result);
+}
+
+/*
+ * call-seq:
+ *   rational == other -> true or false
+ *
+ * Returns true if rational equals other. Comparison is done by cross-multiplication
+ * to avoid floating point precision issues.
+ *
+ *   Rational(1, 2) == Rational(2, 4)  #=> true
+ *   Rational(1, 2) == 0.5             #=> true
+ *   Rational(1, 2) == Rational(1, 3)  #=> false
+ */
+static mrb_value
+rational_eq(mrb_state *mrb, mrb_value x)
+{
+  mrb_value y = mrb_get_arg1(mrb);
+#ifdef RAT_BIGINT
+  if (RAT_BIGINT_P(x)) return rational_eq_b(mrb, x, y);
+#endif
+  struct mrb_rational *p1 = rat_ptr(mrb, x);
+  mrb_bool result;
+
+  switch (mrb_type(y)) {
+  case MRB_TT_INTEGER:
+    if (p1->denominator != 1) return mrb_false_value();
+    result = p1->numerator == mrb_integer(y);
+    break;
+#ifdef MRB_USE_BIGINT
+  case MRB_TT_BIGINT:
+    /* Non-bigint rational comparing with bigint */
+    if (p1->denominator != 1) return mrb_false_value();
+    result = mrb_bint_cmp(mrb, y, mrb_int_value(mrb, p1->numerator)) == 0;
+    break;
+#endif
+#ifndef MRB_NO_FLOAT
+  case MRB_TT_FLOAT:
+    result = ((double)p1->numerator/p1->denominator) == mrb_float(y);
+    break;
+#endif
+  case MRB_TT_RATIONAL:
+    {
+      struct mrb_rational *p2 = rat_ptr(mrb, y);
+      mrb_int a, b;
+
+      if (p1->numerator == p2->numerator && p1->denominator == p2->denominator) {
+        return mrb_true_value();
+      }
+      if (mrb_int_mul_overflow(p1->numerator, p2->denominator, &a) ||
+          mrb_int_mul_overflow(p2->numerator, p1->denominator, &b)) {
+#ifdef MRB_NO_FLOAT
+        rat_overflow(mrb);
+#else
+        result = (double)p1->numerator*p2->denominator == (double)p2->numerator*p2->denominator;
+        break;
+#endif
+      }
+      result = a == b;
+      break;
+    }
+
+#ifdef MRB_USE_COMPLEX
+  case MRB_TT_COMPLEX:
+   {
+      result = mrb_complex_eq(mrb, y, mrb_rational_to_f(mrb, x));
+      break;
+    }
+#endif
+  default:
+    result = mrb_equal(mrb, y, x);
+    break;
+  }
+  return mrb_bool_value(result);
+}
+
+/*
+ * call-seq:
+ *   -rational -> rational
+ *
+ * Returns the negation of the rational number.
+ *
+ *   -Rational(1, 2)   #=> Rational(-1, 2)
+ *   -Rational(-3, 4)  #=> Rational(3, 4)
+ */
+static mrb_value
+rational_minus(mrb_state *mrb, mrb_value x)
+{
+  struct mrb_rational *p = rat_ptr(mrb, x);
+#ifdef RAT_BIGINT
+  mrb_value num;
+  if (RAT_BIGINT_P(x)) {
+    num = mrb_obj_value(p->b.num);
+  bint:
+    return rational_new_b(mrb, mrb_bint_neg(mrb, num), mrb_obj_value(p->b.den));
+  }
+#endif
+  mrb_int n = p->numerator;
+  if (n == MRB_INT_MIN) {
+#ifdef RAT_BIGINT
+    num = mrb_as_bint(mrb, mrb_int_value(mrb, p->numerator));
+    goto bint;
+#else
+    rat_overflow(mrb);
+#endif
+  }
+  return rational_new_i(mrb, -n, p->denominator);
+}
+
+#ifdef RAT_BIGINT
+static mrb_value
+rat_add_b(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  mrb_value num1 = rat_numerator(mrb, x);
+  mrb_value den1 = rat_denominator(mrb, x);
+  mrb_value num2, den2;
+
+  switch(mrb_type(y)) {
+  case MRB_TT_RATIONAL:
+    num2 = rat_numerator(mrb, y);
+    den2 = rat_denominator(mrb, y);
+    break;
+  case MRB_TT_INTEGER:
+  case MRB_TT_BIGINT:
+    num2 = y;
+    den2 = ONE;
+    break;
+  default:
+    /* should not happen */
+    rat_type_error(mrb, y);
+  }
+
+  mrb_value a = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, num1), den2);
+  mrb_value b = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, num2), den1);
+  a = mrb_bint_add_n(mrb, a, b);
+  b = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, den1), den2);
+  return rational_new_b(mrb, a, b);
+}
+#endif
+
+mrb_value
+mrb_rational_add(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  struct mrb_rational *p1 = rat_ptr(mrb, x);
+
+  switch (mrb_type(y)) {
+  case MRB_TT_INTEGER:
+#ifdef RAT_BIGINT
+    if (RAT_BIGINT_P(x)) return rat_add_b(mrb, x, y);
+#endif
+    {
+      mrb_int z = mrb_integer(y);
+      if (mrb_int_mul_overflow(z, p1->denominator, &z)) rat_overflow(mrb);
+      if (mrb_int_add_overflow(p1->numerator, z, &z)) rat_overflow(mrb);
+      return rational_new_i(mrb, z, p1->denominator);
+    }
+  case MRB_TT_RATIONAL:
+#ifdef RAT_BIGINT
+    if (RAT_BIGINT_P(x) || RAT_BIGINT_P(y))
+      return rat_add_b(mrb, x, y);
+#endif
+    {
+      struct mrb_rational *p2 = rat_ptr(mrb, y);
+      mrb_int a, b;
+
+      if (mrb_int_mul_overflow(p1->numerator, p2->denominator, &a)) rat_overflow(mrb);
+      if (mrb_int_mul_overflow(p2->numerator, p1->denominator, &b)) rat_overflow(mrb);
+      if (mrb_int_add_overflow(a, b, &a)) rat_overflow(mrb);
+      if (mrb_int_mul_overflow(p1->denominator, p2->denominator, &b)) rat_overflow(mrb);
+      return rational_new_i(mrb, a, b);
+    }
+
+#ifndef MRB_NO_FLOAT
+  case MRB_TT_FLOAT:
+    {
+      mrb_float z = p1->numerator + mrb_float(y) * p1->denominator;
+      return mrb_float_value(mrb, mrb_div_float(z, (mrb_float)p1->denominator));
+    }
+#endif
+
+#ifdef RAT_BIGINT
+  case MRB_TT_BIGINT:
+    return rat_add_b(mrb, x, y);
+#endif
+
+#if defined(MRB_USE_COMPLEX)
+  case MRB_TT_COMPLEX:
+    return mrb_complex_add(mrb, mrb_complex_new(mrb, rat_float(mrb, x), 0), y);
+#endif
+
+  default:
+    return mrb_funcall_argv(mrb, y, MRB_OPSYM(add), 1, &x);
+  }
+}
+
+/*
+ * call-seq:
+ *   rational + numeric -> rational or numeric
+ *
+ * Returns the sum of rational and numeric. If numeric is a rational,
+ * returns a rational. If numeric is a float, returns a float.
+ *
+ *   Rational(1, 2) + Rational(1, 3)  #=> Rational(5, 6)
+ *   Rational(1, 2) + 1               #=> Rational(3, 2)
+ *   Rational(1, 2) + 0.5             #=> 1.0
+ */
+static mrb_value
+rational_add(mrb_state *mrb, mrb_value x)
+{
+  mrb_value y = mrb_get_arg1(mrb);
+  return mrb_rational_add(mrb, x, y);
+}
+
+#ifdef RAT_BIGINT
+static mrb_value
+rat_sub_b(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  mrb_value num1 = rat_numerator(mrb, x);
+  mrb_value den1 = rat_denominator(mrb, x);
+  mrb_value num2, den2;
+
+  switch(mrb_type(y)) {
+  case MRB_TT_RATIONAL:
+    num2 = rat_numerator(mrb, y);
+    den2 = rat_denominator(mrb, y);
+    break;
+  case MRB_TT_INTEGER:
+  case MRB_TT_BIGINT:
+    num2 = y;
+    den2 = ONE;
+    break;
+  default:
+    /* should not happen */
+    rat_type_error(mrb, y);
+  }
+
+  mrb_value a = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, num1), den2);
+  mrb_value b = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, num2), den1);
+  a = mrb_bint_sub_n(mrb, a, b);
+  b = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, den1), den2);
+  return rational_new_b(mrb, a, b);
+}
+#endif
+
+mrb_value
+mrb_rational_sub(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  struct mrb_rational *p1 = rat_ptr(mrb, x);
+
+  switch (mrb_type(y)) {
+  case MRB_TT_INTEGER:
+#ifdef RAT_BIGINT
+    if (RAT_BIGINT_P(x)) return rat_sub_b(mrb, x, y);
+#endif
+    {
+      mrb_int z = mrb_integer(y);
+      if (mrb_int_mul_overflow(z, p1->denominator, &z)) rat_overflow(mrb);
+      if (mrb_int_sub_overflow(p1->numerator, z, &z)) rat_overflow(mrb);
+      return rational_new_i(mrb, z, p1->denominator);
+    }
+  case MRB_TT_RATIONAL:
+#ifdef RAT_BIGINT
+    if (RAT_BIGINT_P(x) || RAT_BIGINT_P(y))
+      return rat_sub_b(mrb, x, y);
+#endif
+    {
+      struct mrb_rational *p2 = rat_ptr(mrb, y);
+      mrb_int a, b;
+
+      if (mrb_int_mul_overflow(p1->numerator, p2->denominator, &a)) rat_overflow(mrb);
+      if (mrb_int_mul_overflow(p2->numerator, p1->denominator, &b)) rat_overflow(mrb);
+      if (mrb_int_sub_overflow(a, b, &a)) rat_overflow(mrb);
+      if (mrb_int_mul_overflow(p1->denominator, p2->denominator, &b)) rat_overflow(mrb);
+      return rational_new_i(mrb, a, b);
+    }
+
+#ifdef RAT_BIGINT
+  case MRB_TT_BIGINT:
+    return rat_sub_b(mrb, x, y);
+#endif
+
+#if defined(MRB_USE_COMPLEX)
+  case MRB_TT_COMPLEX:
+    return mrb_complex_sub(mrb, mrb_complex_new(mrb, rat_float(mrb, x), 0), y);
+#endif
+
+#ifndef MRB_NO_FLOAT
+  case MRB_TT_FLOAT:
+  default:
+    {
+      mrb_float z = p1->numerator - mrb_as_float(mrb, y) * p1->denominator;
+      return mrb_float_value(mrb, mrb_div_float(z, (mrb_float)p1->denominator));
+    }
+#else
+  default:
+    rat_type_error(mrb, y);
+#endif
+  }
+}
+
+/*
+ * call-seq:
+ *   rational - numeric -> rational or numeric
+ *
+ * Returns the difference of rational and numeric. If numeric is a rational,
+ * returns a rational. If numeric is a float, returns a float.
+ *
+ *   Rational(1, 2) - Rational(1, 3)  #=> Rational(1, 6)
+ *   Rational(3, 2) - 1               #=> Rational(1, 2)
+ *   Rational(1, 2) - 0.25            #=> 0.25
+ */
+static mrb_value
+rational_sub(mrb_state *mrb, mrb_value x)
+{
+  mrb_value y = mrb_get_arg1(mrb);
+  return mrb_rational_sub(mrb, x, y);
+}
+
+#ifdef RAT_BIGINT
+static mrb_value
+rat_mul_b(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  mrb_value num, den;
+
+  switch(mrb_type(y)) {
+  case MRB_TT_RATIONAL:
+    num = rat_numerator(mrb, y);
+    den = rat_denominator(mrb, y);
+    break;
+  case MRB_TT_INTEGER:
+  case MRB_TT_BIGINT:
+    num = y;
+    den = ONE;
+    break;
+  default:
+    /* should not happen */
+    rat_type_error(mrb, y);
+  }
+
+  mrb_value a = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, rat_numerator(mrb, x)), num);
+  mrb_value b = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, rat_denominator(mrb, x)), den);
+  return rational_new_b(mrb, a, b);
+}
+#endif
+
+mrb_value
+mrb_rational_mul(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  switch (mrb_type(y)) {
+  case MRB_TT_INTEGER:
+#ifdef RAT_BIGINT
+    if (RAT_BIGINT_P(x)) return rat_mul_b(mrb, x, y);
+#endif
+    {
+      struct mrb_rational *p1 = rat_ptr(mrb, x);
+      mrb_int z = mrb_integer(y);
+      if (mrb_int_mul_overflow(p1->numerator, z, &z)) rat_overflow(mrb);
+      return rational_new_i(mrb, z, p1->denominator);
+    }
+  case MRB_TT_RATIONAL:
+#ifdef RAT_BIGINT
+    if (RAT_BIGINT_P(x) || RAT_BIGINT_P(y))
+      return rat_mul_b(mrb, x, y);
+#endif
+    {
+      struct mrb_rational *p1 = rat_ptr(mrb, x);
+      struct mrb_rational *p2 = rat_ptr(mrb, y);
+      mrb_int a, b;
+
+      if (mrb_int_mul_overflow(p1->numerator, p2->numerator, &a)) rat_overflow(mrb);
+      if (mrb_int_mul_overflow(p1->denominator, p2->denominator, &b)) rat_overflow(mrb);
+      return rational_new_i(mrb, a, b);
+    }
+
+#ifdef RAT_BIGINT
+  case MRB_TT_BIGINT:
+    return rat_mul_b(mrb, x, y);
+#endif
+
+#ifndef MRB_NO_FLOAT
+  case MRB_TT_FLOAT:
+    {
+      struct mrb_rational *p1 = rat_ptr(mrb, x);
+      mrb_float z = p1->numerator * mrb_float(y);
+      return mrb_float_value(mrb, mrb_div_float(z, (mrb_float)p1->denominator));
+  }
+#endif
+
+#if defined(MRB_USE_COMPLEX)
+  case MRB_TT_COMPLEX:
+    return mrb_complex_mul(mrb, mrb_complex_new(mrb, rat_float(mrb, x), 0), y);
+#endif
+
+  default:
+    return mrb_funcall_argv(mrb, y, MRB_OPSYM(mul), 1, &x);
+  }
+}
+
+/*
+ * call-seq:
+ *   rational * numeric -> rational or numeric
+ *
+ * Returns the product of rational and numeric. Uses standard rational
+ * multiplication: (a/b) * (c/d) = (a*c)/(b*d).
+ *
+ *   Rational(1, 2) * Rational(2, 3)  #=> Rational(1, 3)
+ *   Rational(1, 2) * 3               #=> Rational(3, 2)
+ *   Rational(1, 2) * 2.0             #=> 1.0
+ */
+static mrb_value
+rational_mul(mrb_state *mrb, mrb_value x)
+{
+  mrb_value y = mrb_get_arg1(mrb);
+  return mrb_rational_mul(mrb, x, y);
+}
+
+#ifdef RAT_BIGINT
+static mrb_value
+rat_div_b(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  mrb_value num, den;
+
+  switch(mrb_type(y)) {
+  case MRB_TT_RATIONAL:
+    num = rat_numerator(mrb, y);
+    den = rat_denominator(mrb, y);
+    break;
+  case MRB_TT_INTEGER:
+#ifdef MRB_USE_BIGINT
+  case MRB_TT_BIGINT:
+#endif
+    num = y;
+    den = ONE;
+    break;
+  default:
+    /* should not happen */
+    rat_type_error(mrb, y);
+  }
+
+  mrb_value a = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, rat_numerator(mrb, x)), den);
+  mrb_value b = mrb_bint_mul_n(mrb, mrb_as_bint(mrb, rat_denominator(mrb, x)), num);
+  return rational_new_b(mrb, a, b);
+}
+#endif
+
+mrb_value
+mrb_rational_div(mrb_state *mrb, mrb_value x, mrb_value y)
+{
+  switch (mrb_type(y)) {
+  case MRB_TT_INTEGER:
+#ifdef RAT_BIGINT
+    if (RAT_BIGINT_P(x)) return rat_div_b(mrb, x, y);
+#endif
+    {
+      struct mrb_rational *p1 = rat_ptr(mrb, x);
+      mrb_int z = mrb_integer(y);
+      if (z == 0) mrb_int_zerodiv(mrb);
+      if (mrb_int_mul_overflow(p1->denominator, z, &z)) rat_overflow(mrb);
+      return rational_new_i(mrb, p1->numerator, z);
+    }
+  case MRB_TT_RATIONAL:
+#ifdef RAT_BIGINT
+    if (RAT_BIGINT_P(x) || RAT_BIGINT_P(y)) return rat_div_b(mrb, x, y);
+#endif
+    {
+      struct mrb_rational *p1 = rat_ptr(mrb, x);
+      struct mrb_rational *p2 = rat_ptr(mrb, y);
+      mrb_int a, b;
+
+      if (mrb_int_mul_overflow(p1->numerator, p2->denominator, &a)) rat_overflow(mrb);
+      if (mrb_int_mul_overflow(p2->numerator, p1->denominator, &b)) rat_overflow(mrb);
+      return rational_new_i(mrb, a, b);
+    }
+
+#ifdef RAT_BIGINT
+  case MRB_TT_BIGINT:
+    return rat_div_b(mrb, x, y);
+#endif
+
+#ifdef MRB_USE_COMPLEX
+  case MRB_TT_COMPLEX:
+    return mrb_complex_div(mrb, mrb_complex_new(mrb, rat_float(mrb, x), 0), y);
+#endif
+
+#ifndef MRB_NO_FLOAT
+  case MRB_TT_FLOAT:
+    {
+      struct mrb_rational *p1 = rat_ptr(mrb, x);
+      mrb_float z = mrb_div_float((mrb_float)p1->numerator, mrb_as_float(mrb, y));
+      return mrb_float_value(mrb, mrb_div_float(z, (mrb_float)p1->denominator));
+    }
+#endif
+
+  default:
+    rat_type_error(mrb, y);
+    /* not reached */
+    return mrb_nil_value();
+  }
+}
+
+/*
+ * call-seq:
+ *   rational / numeric -> rational or numeric
+ *   rational.quo(numeric) -> rational or numeric
+ *
+ * Returns the quotient of rational divided by numeric. Uses standard rational
+ * division: (a/b) / (c/d) = (a/b) * (d/c) = (a*d)/(b*c).
+ *
+ *   Rational(1, 2) / Rational(1, 3)  #=> Rational(3, 2)
+ *   Rational(3, 4) / 2               #=> Rational(3, 8)
+ *   Rational(1, 2) / 0.5             #=> 1.0
+ */
+static mrb_value
+rational_div(mrb_state *mrb, mrb_value x)
+{
+  mrb_value y = mrb_get_arg1(mrb);
+  return mrb_rational_div(mrb, x, y);
+}
+
+mrb_value mrb_int_pow(mrb_state *mrb, mrb_value x, mrb_value y);
+
+/*
+ * call-seq:
+ *   rational ** numeric -> numeric
+ *
+ * Returns rational raised to the power of numeric. The result is typically
+ * a float unless the result can be exactly represented as a rational.
+ *
+ *   Rational(1, 2) ** 2    #=> Rational(1, 4)
+ *   Rational(4, 1) ** 0.5  #=> 2.0
+ *   Rational(2, 1) ** 3    #=> Rational(8, 1)
+ */
+static mrb_value
+rational_pow(mrb_state *mrb, mrb_value x)
+{
+#ifndef MRB_NO_FLOAT
+  mrb_value y = mrb_get_arg1(mrb);
+  double d1 = rat_float(mrb, x);
+  double d2 = mrb_as_float(mrb, y);
+
+  d1 = pow(d1, d2);
+  switch (mrb_type(y)) {
+  case MRB_TT_FLOAT:
+    return mrb_float_value(mrb, d1);
+  case MRB_TT_INTEGER:
+  case MRB_TT_RATIONAL:
+    return rational_new_f(mrb, d1);
+  case MRB_TT_BIGINT:
+  default:
+    return mrb_float_value(mrb, d1);
+  }
+#else
+  mrb_raisef(mrb, E_NOTIMP_ERROR, "Rational#** not implemented with MRB_NO_FLOAT");
+  /* not reached */
+  return mrb_nil_value();
+#endif
+}
+
+/*
+ * call-seq:
+ *   rational.hash -> integer
+ *
+ * Returns a hash value for the rational number. Two rationals with
+ * the same value will have the same hash value.
+ *
+ *   Rational(1, 2).hash == Rational(2, 4).hash  #=> true
+ */
+static mrb_value
+rational_hash(mrb_state *mrb, mrb_value rat)
+{
+  struct mrb_rational *r = rat_ptr(mrb, rat);
+  uint32_t hash;
+
+#ifdef RAT_BIGINT
+  if (RAT_BIGINT_P(rat)) {
+    mrb_value tmp = mrb_bint_hash(mrb, mrb_obj_value(r->b.num));
+    hash = (uint32_t)mrb_integer(tmp);
+    tmp = mrb_bint_hash(mrb, mrb_obj_value(r->b.den));
+    hash ^= (uint32_t)mrb_integer(tmp);
+    return mrb_int_value(mrb, hash);
+  }
+#endif
+  hash = mrb_byte_hash((uint8_t*)&r->numerator, sizeof(mrb_int));
+  hash = mrb_byte_hash_step((uint8_t*)&r->denominator, sizeof(mrb_int), hash);
+  return mrb_int_value(mrb, hash);
+}
+
+/* ---------------------------*/
+static const mrb_mt_entry rational_rom_entries[] = {
+  MRB_MT_ENTRY(rational_numerator,   MRB_SYM(numerator), MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(rational_denominator, MRB_SYM(denominator), MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(mrb_rational_to_i,    MRB_SYM(to_i),     MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(mrb_obj_itself,       MRB_SYM(to_r),     MRB_ARGS_NONE()),  /* Returns self - already a rational */
+  MRB_MT_ENTRY(rational_negative_p,  MRB_SYM_Q(negative), MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(rational_eq,          MRB_OPSYM(eq), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(rational_minus,       MRB_OPSYM(minus),  MRB_ARGS_NONE()),
+  MRB_MT_ENTRY(rational_add,         MRB_OPSYM(add), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(rational_sub,         MRB_OPSYM(sub), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(rational_mul,         MRB_OPSYM(mul), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(rational_div,         MRB_OPSYM(div), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(rational_div,         MRB_SYM(quo), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(rational_pow,         MRB_OPSYM(pow), MRB_ARGS_REQ(1)),
+  MRB_MT_ENTRY(rational_hash,        MRB_SYM(hash),     MRB_ARGS_NONE()),
+#ifndef MRB_NO_FLOAT
+  MRB_MT_ENTRY(mrb_rational_to_f,   MRB_SYM(to_f),     MRB_ARGS_NONE()),
+#endif
+};
+
+void mrb_mruby_rational_gem_init(mrb_state *mrb)
+{
+  struct RClass *rat = mrb_define_class_id(mrb, MRB_SYM(Rational), mrb_class_get_id(mrb, MRB_SYM(Numeric)));
+  MRB_SET_INSTANCE_TT(rat, MRB_TT_RATIONAL);
+  MRB_UNDEF_ALLOCATOR(rat);
+  mrb_undef_class_method_id(mrb, rat, MRB_SYM(new));
+  MRB_MT_INIT_ROM(mrb, rat, rational_rom_entries);
+  mrb_define_method_id(mrb, mrb->integer_class, MRB_SYM(to_r), int_to_r, MRB_ARGS_NONE());
+  mrb_define_method_id(mrb, mrb->nil_class, MRB_SYM(to_r), nil_to_r, MRB_ARGS_NONE());
+  mrb_define_private_method_id(mrb, mrb->kernel_module, MRB_SYM(Rational), rational_m, MRB_ARGS_REQ(1)|MRB_ARGS_OPT(1));
+#ifndef MRB_NO_FLOAT
+  mrb_define_method_id(mrb, mrb->float_class, MRB_SYM(to_r), float_to_r, MRB_ARGS_NONE());
+#endif
+}
+
+void
+mrb_mruby_rational_gem_final(mrb_state* mrb)
+{
+}