gmp 0.4.0-x86-mingw32

data/ext/gmpf.h

@@ -0,0 +1,144 @@
+#ifndef _GMPF_H_
+#define _GMPF_H_
+
+/*
+ * gmpf.h
+ *
+ * This file contains GMP::F stuff.
+ */
+
+#include <ruby_gmp.h>
+
+#ifdef MPFR
+#define MPFR_SINGLE_FUNCTION(name)                                \
+static VALUE r_gmpfr_##name(VALUE self)                           \
+{                                                                 \
+  MP_FLOAT *self_val, *res_val;                                   \
+  unsigned long prec;                                             \
+  VALUE res;                                                      \
+                                                                  \
+  mpf_get_struct_prec(self, self_val, prec);                      \
+  mpf_make_struct_init(res, res_val, prec);                       \
+  mpfr_##name(res_val, self_val, __gmp_default_rounding_mode);    \
+                                                                  \
+  return res;                                                     \
+}
+
+MPFR_SINGLE_FUNCTION(log)
+MPFR_SINGLE_FUNCTION(exp)
+MPFR_SINGLE_FUNCTION(sqrt)
+MPFR_SINGLE_FUNCTION(cos)
+MPFR_SINGLE_FUNCTION(sin)
+MPFR_SINGLE_FUNCTION(tan)
+MPFR_SINGLE_FUNCTION(acos)
+MPFR_SINGLE_FUNCTION(asin)
+MPFR_SINGLE_FUNCTION(atan)
+MPFR_SINGLE_FUNCTION(cosh)
+MPFR_SINGLE_FUNCTION(sinh)
+MPFR_SINGLE_FUNCTION(tanh)
+MPFR_SINGLE_FUNCTION(acosh)
+MPFR_SINGLE_FUNCTION(asinh)
+MPFR_SINGLE_FUNCTION(atanh)
+MPFR_SINGLE_FUNCTION(log1p)
+MPFR_SINGLE_FUNCTION(expm1)
+MPFR_SINGLE_FUNCTION(log2)
+MPFR_SINGLE_FUNCTION(log10)
+
+static VALUE r_gmpfr_nan_p(VALUE self)
+{
+  MP_FLOAT *self_val;
+
+  mpf_get_struct(self, self_val);
+  if (mpfr_nan_p(self_val)) {
+    return Qtrue;
+  }
+  else {
+    return Qfalse;
+  }
+}
+
+static VALUE r_gmpfr_inf_p(VALUE self)
+{
+  MP_FLOAT *self_val;
+
+  mpf_get_struct(self, self_val);
+  if (mpfr_inf_p(self_val)) {
+    return Qtrue;
+  }
+  else {
+    return Qfalse;
+  }
+}
+
+static VALUE r_gmpfr_fin_p(VALUE self)
+{
+  if (r_gmpfr_inf_p(self)) {
+    return Qfalse;
+  }
+  else {
+    return Qtrue;
+  }
+}
+
+static VALUE r_gmpfr_number_p(VALUE self)
+{
+  MP_FLOAT *self_val;
+
+  mpf_get_struct(self, self_val);
+  if (mpfr_number_p(self_val)) {
+    return Qtrue;
+  }
+  else {
+    return Qfalse;
+  }
+}
+
+static VALUE r_gmpfr_pow(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val, *res_val, *arg_val_f;
+  MP_RAT *arg_val_q;
+  MP_INT *arg_val_z;
+  unsigned long prec;
+  VALUE res;
+
+  mpf_get_struct_prec(self, self_val, prec);
+
+  if (GMPF_P(arg)) {
+    mpf_get_struct(arg, arg_val_f);
+    prec_max(prec, arg_val_f);
+    mpf_make_struct_init(res, res_val, prec);
+    mpfr_pow(res_val, self_val, arg_val_f, __gmp_default_rounding_mode);
+  } else {
+    mpf_make_struct_init(res, res_val, prec);
+
+    if (GMPZ_P(arg)) {
+      mpz_get_struct(arg, arg_val_z);
+      mpf_set_z(res_val, arg_val_z);
+      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    } else if (GMPQ_P(arg)) {
+      mpq_get_struct(arg, arg_val_q);
+      mpf_set_q(res_val, arg_val_q);
+      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    } else if (FLOAT_P(arg)) {
+      mpf_set_d(res_val, FLT2DBL(arg));
+      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    } else if (FIXNUM_P(arg)) {
+      mpfr_pow_si(res_val, self_val, FIX2INT(arg), __gmp_default_rounding_mode);
+    } else if (BIGNUM_P(arg)) {
+      mpz_temp_from_bignum(arg_val_z, arg);
+      mpf_set_z(res_val, arg_val_z);
+      mpz_temp_free(arg_val_z);
+      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    } else {
+      typeerror(ZQFXBD);
+    }
+
+  }
+
+  return res;
+}
+
+#endif
+
+
+#endif

data/ext/gmpq.c

@@ -0,0 +1,780 @@
+#include <gmpz.h>
+#include <gmpq.h>
+#include <gmpf.h>
+
+/*
+ * Document-class: GMP::Q
+ *
+ * GMP Multiple Precision Rational Number.
+ *
+ * Instances of this class can store variables of the type mpq_t. This class
+ * also contains many methods that act as the functions for mpq_t variables,
+ * as well as a few methods that attempt to make this library more Ruby-ish.
+ *
+ * The following list is just a simple checklist for me, really. A better
+ * reference should be found in the rdocs.
+ *
+ *   Ruby method  C Extension function  GMP function
+ *   to_d         r_gmpq_to_d           mpq_get_d
+ *   to_s         r_gmpq_to_s           ?
+ *   add          r_gmpq_add            mpq_add
+ *   sub          r_gmpq_sub            mpq_sub
+ *   mul          r_gmpq_mul            mpq_mul
+ *   div          r_gmpq_div            mpq_div
+ *   -@           r_gmpq_neg            mpq_neg
+ *   neg          r_gmpq_neg            mpq_neg
+ *   neg!         r_gmpq_neg_self       mpq_neg
+ *   abs          r_gmpq_abs            mpq_abs
+ *   abs!         r_gmpq_abs_self       mpq_abs
+ */
+
+/**********************************************************************
+ *    Macros                                                          *
+ **********************************************************************/
+
+#define DEFUN_RAT_CMP(name,CMP_OP)                             \
+static VALUE r_gmpq_cmp_##name(VALUE self, VALUE arg)          \
+{                                                              \
+  MP_RAT *self_val;                                            \
+  mpq_get_struct(self,self_val);                               \
+  return (mpq_cmp_value(self_val, arg) CMP_OP 0)?Qtrue:Qfalse; \
+}
+
+#define DEFUN_RAT2INT(fname,mpz_fname)                            \
+static VALUE r_gmpq_##fname(VALUE self)                           \
+{                                                                 \
+  MP_RAT *self_val;                                               \
+  MP_INT *res_val;                                                \
+  VALUE res;                                                      \
+                                                                  \
+  mpq_get_struct(self, self_val);                                 \
+  mpz_make_struct_init(res, res_val)                              \
+  mpz_fname(res_val, mpq_numref(self_val), mpq_denref(self_val)); \
+  return res;                                                     \
+}
+
+
+/**********************************************************************
+ *    Initializing Rationals                                          *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   GMP::Q.new(arg)
+ *
+ * Creates a new GMP::Q rational, with arg as its value, converting where
+ * necessary.
+ */
+VALUE r_gmpqsg_new(int argc, VALUE *argv, VALUE klass)
+{
+  MP_RAT *res_val;
+  VALUE res;
+
+  (void)klass;
+
+  if (argc > 2)
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0, 1 or 2)", argc);
+
+  mpq_make_struct (res, res_val);
+  mpq_init (res_val);
+  rb_obj_call_init(res, argc, argv);
+ 
+  return res;
+}
+
+/*
+ * call-seq:
+ *   GMP::Q(arg)
+ *
+ * A convenience method for +GMP::Q.new(arg)+.
+ */
+VALUE r_gmpmod_q(int argc, VALUE *argv, VALUE module)
+{
+  (void)module;
+  return r_gmpqsg_new(argc, argv, cGMP_Q);
+}
+
+/*
+ * call-seq:
+ *   rat1.swap rat2
+ *
+ * Efficiently swaps the contents of +rat1+ with +rat2+.
+ */
+VALUE r_gmpq_swap(VALUE self, VALUE arg)
+{
+  MP_RAT *self_val, *arg_val;
+
+  if (!GMPQ_P(arg)) {
+    rb_raise(rb_eTypeError, "Can't swap GMP::Q with object of other class");
+  }
+
+  mpq_get_struct(self, self_val);
+  mpq_get_struct(arg, arg_val);
+  mpq_swap(self_val,arg_val);
+
+  return Qnil;
+}
+
+
+/**********************************************************************
+ *    Rational Conversions                                            *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   rational.to_d
+ *
+ * Returns +rational+ as an Float if +rational+ fits in a Float.
+ *
+ * Otherwise returns the least significant part of +rational+, with the same
+ * sign as +rational+.
+ *
+ * If the exponent from the conversion is too big or too small to fit a double
+ * then the result is system dependent. For too big an infinity is returned
+ * when available. For too small 0.0 is normally returned. Hardware overflow,
+ * underflow and denorm traps may or may not occur. 
+ */
+VALUE r_gmpq_to_d(VALUE self)
+{
+  MP_RAT *self_val;
+  mpq_get_struct(self, self_val);
+
+  return rb_float_new(mpq_get_d(self_val));
+}
+
+/*
+ * Document-method: to_s
+ *
+ * call-seq:
+ *   rational.to_s
+ *
+ * Returns the decimal representation of +rational+, as a Ruby string.
+ */
+VALUE r_gmpq_to_s(VALUE self)
+{
+  MP_RAT *self_val;
+  MP_INT *self_val_num, *self_val_den;
+  char *str;
+  VALUE res;
+  int sizeinbase;
+  int offset;
+
+  Data_Get_Struct(self, MP_RAT, self_val);
+
+  if (mpz_cmp_ui(mpq_denref(self_val), 1) == 0) {
+    str = mpz_get_str(NULL, 10, mpq_numref (self_val));
+    res = rb_str_new2(str);
+    free (str);
+    return res;
+  }
+
+  self_val_num = mpq_numref(self_val);
+  self_val_den = mpq_denref(self_val);
+
+  sizeinbase = mpz_sizeinbase (self_val_num, 10) + mpz_sizeinbase (self_val_den, 10) + 3;
+  str = malloc (sizeinbase);
+
+  mpz_get_str (str, 10, self_val_num);
+  offset = strlen (str);
+  str[offset] = '/';
+  mpz_get_str (str + offset + 1, 10, self_val_den);
+  res = rb_str_new2(str);
+  free (str);
+
+  return res;
+}
+
+
+/**********************************************************************
+ *    Rational Arithmetic                                             *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   rat1 + rat2
+ *
+ * Adds +rat1+ to +rat2+. +rat2+ can be
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpq_add(VALUE self, VALUE arg)
+{
+  MP_RAT *self_val, *arg_val_q, *res_val;
+  MP_INT *arg_val_z, *res_val_num;
+  VALUE res;
+
+  mpq_get_struct(self, self_val);
+  mpq_make_struct_init(res, res_val);
+
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg,arg_val_q);
+    mpq_add(res_val, self_val, arg_val_q);
+  } else if (GMPZ_P(arg)) {
+    res_val_num = mpq_numref(res_val);
+    mpz_set(mpq_denref(res_val), mpq_denref(self_val));
+    mpz_get_struct(arg, arg_val_z);
+    mpz_mul(res_val_num, mpq_denref(self_val), arg_val_z);
+    mpz_add(res_val_num, res_val_num, mpq_numref(self_val));
+  } else if (FIXNUM_P(arg)) {
+    res_val_num = mpq_numref(res_val);
+    mpz_set(mpq_denref(res_val), mpq_denref(self_val));
+    mpz_mul_si(res_val_num, mpq_denref(self_val), FIX2INT(arg));
+    mpz_add(res_val_num, res_val_num, mpq_numref(self_val));
+  } else if (GMPF_P(arg)) {
+    return r_gmpf_add(arg,self);
+  } else if (BIGNUM_P(arg)) {
+    res_val_num = mpq_numref(res_val);
+    mpz_set(mpq_denref(res_val), mpq_denref(self_val));
+    mpz_set_bignum(res_val_num, arg);
+    mpz_mul(res_val_num, res_val_num, mpq_denref(self_val));
+    mpz_add(res_val_num, res_val_num, mpq_numref(self_val));
+  } else {
+    typeerror(ZQFXB);
+  }
+  return res;
+}
+
+/*
+ * call-seq:
+ *   rat1 - rat2
+ *
+ * Subtracts +rat2+ from +rat1+. +rat2+ can be
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpq_sub(VALUE self, VALUE arg)
+{
+  MP_RAT *self_val, *arg_val_q, *res_val;
+  MP_INT *arg_val_z, *res_val_num;
+  MP_FLOAT *arg_val_f, *res_val_f;
+  VALUE res;
+  unsigned int prec;
+
+  mpq_get_struct(self, self_val);
+  mpq_make_struct_init(res, res_val);
+
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg,arg_val_q);
+    mpq_sub (res_val, self_val, arg_val_q);
+  } else if (GMPZ_P(arg)) {
+    res_val_num = mpq_numref(res_val);
+    mpz_set (mpq_denref(res_val), mpq_denref(self_val));
+    mpz_get_struct(arg, arg_val_z);
+    mpz_mul (res_val_num, mpq_denref(self_val), arg_val_z);
+    mpz_neg (res_val_num, res_val_num);
+    mpz_add (res_val_num, res_val_num, mpq_numref(self_val));
+  } else if (FIXNUM_P(arg)) {
+    res_val_num = mpq_numref(res_val);
+    mpz_set (mpq_denref(res_val), mpq_denref(self_val));
+    mpz_mul_si (res_val_num, mpq_denref(self_val), -FIX2INT(arg));
+    mpz_add (res_val_num, res_val_num, mpq_numref(self_val));
+  } else if (GMPF_P(arg)) {
+    mpf_get_struct_prec (arg, arg_val_f, prec);
+    mpf_make_struct_init(res, res_val_f, prec);
+    mpf_set_q (res_val_f, self_val);
+    mpf_sub (res_val_f, res_val_f, arg_val_f);
+  } else if (BIGNUM_P(arg)) {
+    res_val_num = mpq_numref(res_val);
+    mpz_set (mpq_denref(res_val), mpq_denref(self_val));
+    mpz_set_bignum (res_val_num, arg);
+    mpz_mul (res_val_num, res_val_num, mpq_denref(self_val));
+    mpz_neg (res_val_num, res_val_num);
+    mpz_add (res_val_num, res_val_num, mpq_numref(self_val));
+  } else {
+    typeerror (ZQFXB);
+  }
+  return res;
+}
+
+/*
+ * call-seq:
+ *   rat1 * rat2
+ *
+ * Multiplies +rat1+ with +rat2+. +rat2+ can be
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpq_mul(VALUE self, VALUE arg)
+{
+  MP_RAT *self_val, *arg_val_q, *res_val;
+  MP_INT *arg_val_z, *tmp_z;
+  VALUE res;
+#if GMP >= 4
+  unsigned long tmp_ui;
+#endif
+
+  mpq_get_struct(self, self_val);
+  mpq_make_struct_init(res, res_val);
+
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg,arg_val_q);
+    mpq_mul(res_val, self_val, arg_val_q);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct(arg,arg_val_z);
+    mpz_temp_init(tmp_z);
+    mpz_gcd(tmp_z, mpq_denref(self_val), arg_val_z);
+    mpz_divexact(mpq_denref(res_val), mpq_denref(self_val), tmp_z);
+    mpz_divexact(mpq_numref(res_val), arg_val_z, tmp_z);
+    mpz_mul(mpq_numref(res_val), mpq_numref(res_val), mpq_numref(self_val));
+    mpz_temp_free(tmp_z);
+  } else if (FIXNUM_P(arg)) {
+#if GMP >= 4
+    if (FIX2INT(arg) > 0) {
+      tmp_ui = mpz_gcd_ui(0, mpq_denref(self_val), FIX2INT(arg));
+    } else if (FIX2INT(arg) < 0) {
+      tmp_ui = mpz_gcd_ui(0, mpq_denref(self_val), -FIX2INT(arg));
+    } else {
+      mpz_set_ui(mpq_numref(res_val), 0);
+      mpz_set_ui(mpq_denref(res_val), 1);
+      return res;
+    }
+    mpz_divexact_ui(mpq_denref(res_val), mpq_denref(self_val), tmp_ui);
+    mpz_mul_ui(mpq_numref(res_val), mpq_numref(self_val), FIX2INT(arg)/tmp_ui);
+#else
+    mpz_set(mpq_denref(res_val), mpq_denref(self_val));
+    mpz_mul_si(mpq_numref(res_val), mpq_numref(self_val), FIX2INT(arg));
+    mpq_canonicalize(res_val);
+#endif
+  } else if (GMPF_P(arg)) {
+    return r_gmpf_mul(arg, self);
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_alloc(tmp_z);
+    mpz_set_bignum(tmp_z, arg);
+    mpz_gcd(mpq_denref(res_val), mpq_denref(self_val), tmp_z);
+    mpz_divexact(mpq_numref(res_val), tmp_z, mpq_denref(res_val));
+    mpz_divexact(mpq_denref(res_val), mpq_denref(self_val), mpq_denref(res_val));
+    mpz_mul(mpq_numref(res_val), mpq_numref(res_val), mpq_numref(self_val));
+    mpz_temp_free(tmp_z);
+  } else {
+    typeerror(ZQFXB);
+  }
+  return res;
+}
+
+/*
+ * call-seq:
+ *   rat1 / rat2
+ *
+ * Divides +rat1+ by +rat2+. +rat2+ can be
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpq_div(VALUE self, VALUE arg)
+{
+  MP_RAT *self_val, *arg_val_q, *res_val;
+  MP_INT *arg_val_z, *tmp_z;
+  MP_FLOAT *arg_val_f, *res_val_f;
+  VALUE res;
+  unsigned long tmp_ui, prec;
+
+  mpq_get_struct(self, self_val);
+  mpq_make_struct_init(res, res_val);
+
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg,arg_val_q);
+    if (mpz_sgn(mpq_numref(arg_val_q)) == 0)
+      rb_raise(rb_eZeroDivError, "divided by 0");
+    mpq_div(res_val, self_val, arg_val_q);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct(arg,arg_val_z);
+    mpz_temp_init(tmp_z);
+    mpz_gcd(tmp_z, mpq_numref(self_val), arg_val_z);
+    mpz_divexact(mpq_numref(res_val), mpq_numref(self_val), tmp_z);
+    mpz_divexact(mpq_denref(res_val), arg_val_z, tmp_z);
+    mpz_mul(mpq_denref(res_val), mpq_denref(res_val), mpq_denref(self_val));
+    mpz_temp_free(tmp_z);
+  } else if (FIXNUM_P(arg)) {
+    if (FIX2INT(arg) == 0)
+      rb_raise(rb_eZeroDivError, "divided by 0");
+    if (FIX2INT(arg) > 0) {
+      tmp_ui = mpz_gcd_ui(0, mpq_numref(self_val), FIX2INT(arg));
+    } else {
+      tmp_ui = mpz_gcd_ui(0, mpq_numref(self_val), -FIX2INT(arg));
+    }
+    mpz_divexact_ui(mpq_numref(res_val), mpq_numref(self_val), tmp_ui);
+    mpz_mul_ui(mpq_denref(res_val), mpq_denref(self_val), FIX2INT(arg)/tmp_ui);
+  } else if (GMPF_P(arg)) {
+    mpf_get_struct_prec(arg, arg_val_f, prec);
+    mpf_make_struct_init(res, res_val_f, prec);
+    mpf_set_q(res_val_f, self_val);
+    mpf_div(res_val_f, res_val_f, arg_val_f);
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_alloc(tmp_z);
+    mpz_set_bignum(tmp_z, arg);
+    mpz_gcd(mpq_numref(res_val), mpq_numref(self_val), tmp_z);
+    mpz_divexact(mpq_denref(res_val), tmp_z, mpq_numref(res_val));
+    mpz_divexact(mpq_numref(res_val), mpq_numref(self_val), mpq_numref(res_val));
+    mpz_mul(mpq_denref(res_val), mpq_denref(res_val), mpq_denref(self_val));
+    mpz_temp_free(tmp_z);
+  } else {
+    typeerror(ZQFXB);
+  }
+  return res;
+}
+
+DEFUN_RAT2INT(floor,mpz_fdiv_q)
+DEFUN_RAT2INT(trunc,mpz_tdiv_q)
+DEFUN_RAT2INT(ceil,mpz_cdiv_q)
+
+/*
+ * Document-method: neg
+ *
+ * call-seq:
+ *   -rational
+ *   rational.neg
+ *
+ * From the GMP Manual:
+ * 
+ * Returns -+rational+.
+ */
+VALUE r_gmpq_neg(VALUE self)
+{
+  MP_RAT *self_val, *res_val;
+  VALUE res;
+  mpq_get_struct(self, self_val);
+  mpq_make_struct_init(res, res_val);
+  mpq_neg (res_val, self_val);
+  return res;
+}
+
+/*
+ * Document-method: neg!
+ *
+ * call-seq:
+ *   rational.neg!
+ *
+ * From the GMP Manual:
+ * 
+ * Sets +rational+ to -+rational+.
+ */
+VALUE r_gmpq_neg_self(VALUE self)
+{
+  MP_RAT *self_val;
+  mpq_get_struct(self, self_val);
+  mpz_neg (mpq_numref(self_val), mpq_numref(self_val));
+  return Qnil;
+}
+
+/*
+ * Document-method: abs
+ *
+ * call-seq:
+ *   rational.abs
+ *
+ * From the GMP Manual:
+ * 
+ * Returns the absolute value of +rational+.
+ */
+VALUE r_gmpq_abs(VALUE self)
+{
+  MP_RAT *self_val, *res_val;
+  VALUE res;
+  mpq_get_struct(self, self_val);
+  mpq_make_struct_init(res, res_val);
+  mpz_abs (mpq_numref(res_val), mpq_numref(self_val));
+  mpz_set (mpq_denref(res_val), mpq_denref(self_val));
+
+  return res;
+}
+
+/*
+ * Document-method: abs!
+ *
+ * call-seq:
+ *   rational.abs!
+ *
+ * From the GMP Manual:
+ * 
+ * Sets +rational+ to its absolute value.
+ */
+VALUE r_gmpq_abs_self(VALUE self)
+{
+  MP_RAT *self_val;
+  mpq_get_struct(self, self_val);
+  mpz_abs (mpq_numref(self_val), mpq_numref(self_val));
+  return Qnil;
+}
+
+VALUE r_gmpq_inv(VALUE self)
+{
+  MP_RAT *self_val, *res_val;
+  VALUE res;
+
+  mpq_get_struct(self, self_val);
+  if (mpq_sgn(self_val) == 0)
+    rb_raise (rb_eZeroDivError, "divided by 0");
+  mpq_make_struct_init(res, res_val);
+  mpq_inv (res_val, self_val);
+
+  return res;
+}
+
+VALUE r_gmpq_inv_self(VALUE self)
+{
+  MP_RAT *self_val;
+  mpq_get_struct(self, self_val);
+  if (mpq_sgn(self_val) == 0)
+    rb_raise (rb_eZeroDivError, "divided by 0");
+  mpq_inv (self_val, self_val);
+  return Qnil;
+}
+
+
+/**********************************************************************
+ *    Comparing Rationals                                             *
+ **********************************************************************/
+
+int mpq_cmp_value(MP_RAT *OP, VALUE arg)
+{
+  MP_INT *arg_val_z, *tmp_z;
+  MP_RAT *arg_val_q;
+  int res;
+
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg,arg_val_q);
+    return mpq_cmp(OP,arg_val_q);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct(arg, arg_val_z);
+    mpz_temp_alloc(tmp_z);
+    mpz_init(tmp_z);
+    mpz_mul(tmp_z, mpq_denref(OP), arg_val_z);
+    res = mpz_cmp(mpq_numref(OP),tmp_z);
+    mpz_temp_free(tmp_z);
+    return res;
+  } else if (FIXNUM_P(arg)) {
+    mpz_temp_alloc(tmp_z);
+    mpz_init(tmp_z);
+    mpz_mul_si(tmp_z, mpq_denref(OP), FIX2INT(arg));
+    res = mpz_cmp(mpq_numref(OP), tmp_z);
+    mpz_temp_free(tmp_z);
+    return res;
+  } else if (GMPF_P(arg)) {
+    not_yet;
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(tmp_z, arg);
+    mpz_mul(tmp_z, tmp_z, mpq_denref(OP));
+    res = mpz_cmp(mpq_numref(OP), tmp_z);
+    mpz_temp_free(tmp_z);
+    return res;
+  } else {
+    typeerror(ZQFXB);
+  }
+}
+
+VALUE r_gmpq_eq(VALUE self, VALUE arg)
+{
+  MP_RAT *self_val, *arg_val_q;
+  MP_INT *arg_val_z;
+
+  mpq_get_struct(self,self_val);
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg,arg_val_q);
+    return mpq_equal(self_val,arg_val_q)?Qtrue:Qfalse;
+  } else if (GMPZ_P(arg)) {
+    if (mpz_cmp_ui(mpq_denref(self_val), 1) != 0)
+      return Qfalse;
+    mpz_get_struct (arg, arg_val_z);
+    return (mpz_cmp(mpq_numref(self_val),arg_val_z)==0)?Qtrue:Qfalse;
+  } else if (FIXNUM_P(arg)) {
+    if (mpz_cmp_ui(mpq_denref(self_val), 1) != 0)
+      return Qfalse;
+    return (mpz_cmp_ui(mpq_numref(self_val),FIX2INT(arg))==0)?Qtrue:Qfalse;
+  } else if (BIGNUM_P(arg)) {
+    if (mpz_cmp_ui(mpq_denref(self_val), 1) != 0)
+      return Qfalse;
+    mpz_temp_from_bignum(arg_val_z, arg);
+    if (mpz_cmp (mpq_numref(self_val),arg_val_z) == 0) {
+      mpz_temp_free (arg_val_z);
+      return Qtrue;
+    } else {
+      mpz_temp_free (arg_val_z);
+      return Qfalse;
+    }
+  } else {
+    return Qfalse;
+  }
+}
+
+VALUE r_gmpq_cmp(VALUE self, VALUE arg)
+{
+  MP_RAT *self_val;
+  int res;
+  mpq_get_struct (self,self_val);
+  res = mpq_cmp_value(self_val, arg);
+  if (res > 0)
+    return INT2FIX(1);
+  else if (res == 0)
+    return INT2FIX(0);
+  else
+    return INT2FIX(-1);
+}
+
+DEFUN_RAT_CMP(lt,<)
+DEFUN_RAT_CMP(le,<=)
+DEFUN_RAT_CMP(gt,>)
+DEFUN_RAT_CMP(ge,>=)
+
+static VALUE r_gmpq_cmpabs(VALUE self, VALUE arg)
+{
+  MP_RAT *arg_val_q, *self_val;
+  MP_INT *arg_val_z, *tmp_z;
+  int res;
+  int sgnt;
+
+  mpq_get_struct(self, self_val);
+
+  if (GMPQ_P(arg)) {
+    mpq_get_struct(arg,arg_val_q);
+    sgnt = 3*mpz_sgn(mpq_numref(self_val)) + mpz_sgn(mpq_numref(arg_val_q));
+    switch (sgnt)
+    {
+    default:
+    case 0:
+      return INT2FIX(0);
+    case 1:
+    case -1:
+      return INT2FIX(-1);
+    case 2:
+      tmp_z = mpq_numref(arg_val_q);
+      mpz_neg (tmp_z, tmp_z);
+      res = mpq_cmp (self_val, arg_val_q);
+      mpz_neg (tmp_z, tmp_z);
+      return res;
+    case -2:
+      tmp_z = mpq_numref(arg_val_q);
+      mpz_neg (tmp_z, tmp_z);
+      res = mpq_cmp (self_val, arg_val_q);
+      mpz_neg (tmp_z, tmp_z);
+      return res;
+    case 3:
+    case -3:
+      return INT2FIX(1);
+    case 4:
+    case -4:
+      return INT2FIX(mpq_cmp (self_val,arg_val_q));
+    }
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct(arg, arg_val_z);
+    mpz_temp_alloc (tmp_z);
+    mpz_init (tmp_z);
+    mpz_mul (tmp_z, mpq_denref(self_val), arg_val_z);
+    res = mpz_cmpabs (mpq_numref(self_val),tmp_z);
+    mpz_temp_free (tmp_z);
+    return res;
+  } else if (FIXNUM_P(arg)) {
+    mpz_temp_alloc (tmp_z);
+    mpz_init (tmp_z);
+    mpz_mul_si (tmp_z, mpq_denref(self_val), FIX2INT(arg));
+    res = mpz_cmpabs (mpq_numref(self_val), tmp_z);
+    mpz_temp_free (tmp_z);
+    return res;
+  } else if (GMPF_P(arg)) {
+    not_yet;
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum (tmp_z, arg);
+    mpz_mul (tmp_z, tmp_z, mpq_denref(self_val));
+    res = mpz_cmpabs (mpq_numref(self_val), tmp_z);
+    mpz_temp_free (tmp_z);
+    return res;
+  } else {
+    typeerror (ZQFXB);
+  }
+}
+
+/*
+ * call-seq:
+ *   rational.sgn
+ *
+ * From the GMP Manual:
+ * 
+ * Returns +1 if +rational+ > 0, 0 if +rational+ == 0, and -1 if +rational+ < 0.
+ */
+VALUE r_gmpq_sgn(VALUE self)
+{
+  MP_RAT *self_val;
+  mpq_get_struct(self, self_val);
+  return INT2FIX(mpq_sgn(self_val));
+}
+
+/**********************************************************************
+ *    Applying Integer Functions                                      *
+ **********************************************************************/
+
+VALUE r_gmpq_num(VALUE self)
+{
+  MP_RAT *self_val;
+  MP_INT *res_val;
+  VALUE res;
+  mpq_get_struct(self,self_val);
+  mpz_make_struct(res, res_val);
+  mpz_init_set (res_val, mpq_numref (self_val));
+  return res;
+}
+
+VALUE r_gmpq_den(VALUE self)
+{
+  MP_RAT *self_val;
+  MP_INT *res_val;
+  VALUE res;
+  mpq_get_struct(self,self_val);
+  mpz_make_struct(res, res_val);
+  mpz_init_set (res_val, mpq_denref (self_val));
+  return res;
+}
+
+
+void init_gmpq()
+{
+  mGMP = rb_define_module("GMP");
+  rb_define_module_function(mGMP, "Q", r_gmpmod_q, -1);
+
+  cGMP_Q = rb_define_class_under (mGMP, "Q", rb_cNumeric);
+
+  // Initializing Rationals
+  rb_define_singleton_method(cGMP_Q, "new", r_gmpqsg_new, -1);
+  rb_define_method(cGMP_Q, "swap",  r_gmpq_swap, 1);
+  
+  // Rational Conversions
+  rb_define_method(cGMP_Q, "to_d", r_gmpq_to_d, 0);
+  rb_define_alias(cGMP_Q, "to_f", "to_d");
+  rb_define_method(cGMP_Q, "to_s", r_gmpq_to_s, 0);
+  
+  // Rational Arithmetic
+  rb_define_method(cGMP_Q, "+", r_gmpq_add, 1);
+  rb_define_method(cGMP_Q, "-", r_gmpq_sub, 1);
+  rb_define_method(cGMP_Q, "*", r_gmpq_mul, 1);
+  rb_define_method(cGMP_Q, "/", r_gmpq_div, 1);
+  rb_define_method(cGMP_Q, "-@", r_gmpq_neg, 0);
+  rb_define_method(cGMP_Q, "neg!", r_gmpq_neg_self, 0);
+  rb_define_method(cGMP_Q, "inv", r_gmpq_inv, 0);
+  rb_define_method(cGMP_Q, "inv!", r_gmpq_inv_self, 0);
+  rb_define_method(cGMP_Q, "abs", r_gmpq_abs, 0);
+  rb_define_method(cGMP_Q, "abs!", r_gmpq_abs_self, 0);
+
+  // Comparing Rationals
+  rb_define_method(cGMP_Q, "<=>", r_gmpq_cmp, 1);
+  rb_define_method(cGMP_Q, ">",   r_gmpq_cmp_gt, 1);
+  rb_define_method(cGMP_Q, ">=",  r_gmpq_cmp_ge, 1);
+  rb_define_method(cGMP_Q, "<",   r_gmpq_cmp_lt, 1);
+  rb_define_method(cGMP_Q, "<=",  r_gmpq_cmp_le, 1);
+  rb_define_method(cGMP_Q, "==",  r_gmpq_eq, 1);
+  rb_define_method(cGMP_Q, "sgn", r_gmpq_sgn, 0);
+  rb_define_method(cGMP_Q, "cmpabs",  r_gmpq_cmpabs, 1);
+  
+  // _unsorted_
+  rb_define_method(cGMP_Q, "floor",  r_gmpq_floor, 0);
+  rb_define_method(cGMP_Q, "ceil",  r_gmpq_ceil, 0);
+  rb_define_method(cGMP_Q, "trunc",  r_gmpq_trunc, 0);
+}