srawlins-gmp 0.1.5 → 0.1.5.1

data/CHANGELOG

@@ -1,4 +1,16 @@
-1.1.0:
+0.1.5:
+ * Merged in reorg changes: Files like gmpz.c allow for documenting the C
+   extension methods.
+ * A good portion of the documentation has been written, may not be included
+   yet, but can be generated with
+     rdoc README.rdoc ext/*.c ext/*.h
+
+0.1.4:
+ * Fixed a lot of gemspec problems
+ * Many more tests
+ * Tested on OS X 10.5.8
+
+0.1.1:
 * Attempting to revitalize through GitHub
 * no changes to code yet
 * modernizing files, eg with new ruby standards, towards a gem

data/ext/gmpf.c

@@ -0,0 +1,423 @@
+#include <gmpz.h>
+#include <gmpq.h>
+#include <gmpf.h>
+
+/*
+ * Document-class: GMP::F
+ *
+ * GMP Multiple Precision floating point numbers.
+ *
+ * Instances of this class can store variables of the type mpf_t. This class
+ * also contains many methods that act as the functions for mpf_t variables,
+ * as well as a few methods that attempt to make this library more Ruby-ish.
+ */
+
+/**********************************************************************
+ *    Macros                                                          *
+ **********************************************************************/
+
+#define DEFUN_FLOAT2FLOAT(fname,mpf_fname)                    \
+static VALUE r_gmpf_##fname(VALUE self)                       \
+{                                                             \
+  MP_FLOAT *self_val, *res_val;                               \
+  VALUE res;                                                  \
+  mpf_get_struct(self, self_val);                             \
+  mpf_make_struct_init(res, res_val, mpf_get_prec(self_val)); \
+  mpf_fname(res_val, self_val);                               \
+  return res;                                                 \
+}                                                             \
+                                                              \
+static VALUE r_gmpf_##fname##_self(VALUE self)                \
+{                                                             \
+  MP_FLOAT *self_val;                                         \
+  mpf_get_struct(self, self_val);                             \
+  mpf_fname(self_val, self_val);                              \
+  return Qnil;                                                \
+}
+
+#define DEFUN_FLOAT_CMP(name,CMP_OP)                           \
+static VALUE r_gmpf_cmp_##name(VALUE self, VALUE arg)          \
+{                                                              \
+  MP_FLOAT *self_val;                                          \
+  mpf_get_struct(self,self_val);                               \
+  return (mpf_cmp_value(self_val, arg) CMP_OP 0)?Qtrue:Qfalse; \
+}
+
+
+/**********************************************************************
+ *    Initializing, Assigning Floats                                  *
+ **********************************************************************/
+
+
+/**********************************************************************
+ *    Converting Floats                                               *
+ **********************************************************************/
+
+VALUE r_gmpf_to_d(VALUE self)
+{
+  MP_FLOAT *self_val;
+  mpf_get_struct (self, self_val);
+
+  return rb_float_new(mpf_get_d(self_val));
+}
+
+VALUE r_gmpf_to_s(VALUE self)
+{
+  MP_FLOAT *self_val;
+  char *str, *str2;
+  VALUE res;
+  mp_exp_t exponent;
+
+  mpf_get_struct(self, self_val);
+
+  str = mpf_get_str(NULL, &exponent, 10, 0, self_val);
+  if ((strcmp (str,  "NaN") == 0) ||
+      (strcmp (str,  "Inf") == 0) ||
+      (strcmp (str, "-Inf") == 0))
+  {
+    res = rb_str_new2(str);
+  }
+  else
+  {
+    if (str[0] == '-')
+      __gmp_asprintf (&str2, "-0.%se%+ld", str+1, exponent);
+    else
+      __gmp_asprintf (&str2, "0.%se%+ld", str, exponent);
+    res = rb_str_new2(str2);
+    free (str2);
+  }
+  free (str);
+  return res;
+}
+
+
+/**********************************************************************
+ *    Float Arithmetic                                                *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   float + other
+ *
+ * Returns the sum of +float+ and +other+. +other+ can be
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpf_add(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val, *res_val, *arg_val_f;
+  MP_RAT *arg_val_q;
+  MP_INT *arg_val_z;
+  VALUE res;
+  unsigned long prec;
+
+  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);
+    mpf_add(res_val, self_val, arg_val_f);
+  } else if (GMPQ_P(arg)) {
+    mpq_get_struct (arg, arg_val_q);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_q (res_val, arg_val_q);
+    mpf_add (res_val, res_val, self_val);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_z (res_val, arg_val_z);
+    mpf_add (res_val, res_val, self_val);
+  } else if (FLOAT_P(arg)) {
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_d (res_val, FLT2DBL(arg));
+    mpf_add (res_val, res_val, self_val);
+  } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_si (res_val, FIX2INT(arg));
+    mpf_add (res_val, res_val, self_val);
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(arg_val_z, arg);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_z (res_val, arg_val_z);
+    mpf_add (res_val, res_val, self_val);
+    mpz_temp_free(arg_val_z);
+  } else {
+    typeerror(ZQFXBD);
+  }
+
+  return res;
+}
+
+VALUE r_gmpf_sub(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val, *res_val, *arg_val_f;
+  MP_RAT *arg_val_q;
+  MP_INT *arg_val_z;
+  VALUE res;
+  unsigned long prec;
+
+  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);
+    mpf_sub(res_val, self_val, arg_val_f);
+  } else if (GMPQ_P(arg)) {
+    mpq_get_struct (arg, arg_val_q);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_q (res_val, arg_val_q);
+    mpf_sub (res_val, self_val, res_val);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_z (res_val, arg_val_z);
+    mpf_sub (res_val, self_val, res_val);
+  } else if (FLOAT_P(arg)) {
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_d (res_val, FLT2DBL(arg));
+    mpf_sub (res_val, self_val, res_val);
+  } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_si (res_val, FIX2INT(arg));
+    mpf_sub (res_val, self_val, res_val);
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(arg_val_z, arg);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_z (res_val, arg_val_z);
+    mpf_sub (res_val, res_val, self_val);
+    mpz_temp_free(arg_val_z);
+  } else {
+    typeerror(ZQFXBD);
+  }
+
+  return res;
+}
+
+/*
+ * call-seq:
+ *   float * other
+ *
+ * Returns the product of +float+ and +other+. +other+ can be
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ */
+VALUE r_gmpf_mul(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val, *res_val, *arg_val_f;
+  MP_RAT *arg_val_q;
+  MP_INT *arg_val_z;
+  VALUE res;
+  unsigned long prec;
+
+  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);
+    mpf_mul(res_val, self_val, arg_val_f);
+  } else if (GMPQ_P(arg)) {
+    mpq_get_struct(arg, arg_val_q);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_q(res_val, arg_val_q);
+    mpf_mul(res_val, self_val, res_val);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct(arg, arg_val_z);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_z(res_val, arg_val_z);
+    mpf_mul(res_val, self_val, res_val);
+  } else if (FLOAT_P(arg)) {
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_d(res_val, FLT2DBL(arg));
+    mpf_mul(res_val, self_val, res_val);
+  } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_si(res_val, FIX2INT(arg));
+    mpf_mul(res_val, self_val, res_val);
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(arg_val_z, arg);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_z(res_val, arg_val_z);
+    mpf_mul(res_val, res_val, self_val);
+    mpz_temp_free(arg_val_z);
+  } else {
+    typeerror(ZQFXBD);
+  }
+
+  return res;
+}
+
+VALUE r_gmpf_div(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val, *res_val, *arg_val_f;
+  MP_RAT *arg_val_q;
+  MP_INT *arg_val_z;
+  VALUE res;
+  unsigned long prec;
+
+  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);
+    mpf_div(res_val, self_val, arg_val_f);
+  } else if (GMPQ_P(arg)) {
+    mpq_get_struct (arg, arg_val_q);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_q (res_val, arg_val_q);
+    mpf_div (res_val, self_val, res_val);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_z (res_val, arg_val_z);
+    mpf_div (res_val, self_val, res_val);
+  } else if (FLOAT_P(arg)) {
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_d (res_val, FLT2DBL(arg));
+    mpf_div (res_val, self_val, res_val);
+  } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_si (res_val, FIX2INT(arg));
+    mpf_div (res_val, self_val, res_val);
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(arg_val_z, arg);
+    mpf_make_struct_init(res, res_val, prec);
+    mpf_set_z (res_val, arg_val_z);
+    mpf_div (res_val, res_val, self_val);	
+    mpz_temp_free(arg_val_z);
+  } else {
+    typeerror(ZQFXBD);
+  }
+
+  return res;
+}
+
+DEFUN_FLOAT2FLOAT(abs,mpf_abs)
+DEFUN_FLOAT2FLOAT(neg,mpf_neg)
+
+
+/**********************************************************************
+ *    Float Comparison                                                *
+ **********************************************************************/
+
+int mpf_cmp_value(MP_FLOAT *self_val, VALUE arg)
+{
+  MP_FLOAT *arg_val;
+  int result;
+
+  if (GMPF_P(arg)) {
+    mpf_get_struct(arg,arg_val);
+    return mpf_cmp (self_val, arg_val);
+  } else {
+    mpf_temp_init(arg_val, mpf_get_prec (self_val));
+    mpf_set_value (arg_val, arg);
+    result = mpf_cmp (self_val, arg_val);
+    mpf_temp_free(arg_val);
+    return result;
+  }
+}
+
+/* what does really "equal" mean ? it's not obvious */
+VALUE r_gmpf_eq(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val;
+  mpf_get_struct (self,self_val);
+  return (mpf_cmp_value(self_val, arg) == 0) ? Qtrue : Qfalse;
+}
+
+VALUE r_gmpf_cmp(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val;
+  int res;
+  mpf_get_struct(self,self_val);
+  res = mpf_cmp_value(self_val, arg);
+  if (res > 0)
+    return INT2FIX(1);
+  else if (res == 0)
+    return INT2FIX(0);
+  else
+    return INT2FIX(-1);
+}
+
+DEFUN_FLOAT_CMP(lt,<)
+DEFUN_FLOAT_CMP(le,<=)
+DEFUN_FLOAT_CMP(gt,>)
+DEFUN_FLOAT_CMP(ge,>=)
+
+
+/**********************************************************************
+ *    _unsorted_                                                      *
+ **********************************************************************/
+
+DEFUN_FLOAT2FLOAT(floor,mpf_floor)
+DEFUN_FLOAT2FLOAT(trunc,mpf_trunc)
+DEFUN_FLOAT2FLOAT(ceil,mpf_ceil)
+
+VALUE r_gmpf_sgn(VALUE self)
+{
+  MP_FLOAT *self_val;
+  mpf_get_struct(self, self_val);
+  return INT2FIX(mpf_sgn(self_val));
+}
+
+VALUE r_gmpf_get_prec(VALUE self)
+{
+  MP_FLOAT *self_val;
+  mpf_get_struct(self, self_val);
+  return INT2NUM(mpf_get_prec(self_val));
+}
+
+
+void init_gmpf()
+{
+  mGMP = rb_define_module("GMP");
+  rb_define_module_function(mGMP, "Z", r_gmpmod_z, -1);
+  rb_define_module_function(mGMP, "Q", r_gmpmod_q, -1);
+  rb_define_module_function(mGMP, "F", r_gmpmod_f, -1);
+  
+  cGMP_F = rb_define_class_under (mGMP, "F", rb_cNumeric);
+  
+  
+  // Initializin, Assigning Floats
+  
+  // Converting Floats
+  rb_define_method(cGMP_F, "to_s", r_gmpf_to_s, 0);
+  rb_define_method(cGMP_F, "to_d",  r_gmpf_to_d, 0);
+  
+  // Float Arithmetic
+  rb_define_method(cGMP_F, "+", r_gmpf_add, 1);
+  rb_define_method(cGMP_F, "-", r_gmpf_sub, 1);
+  rb_define_method(cGMP_F, "*", r_gmpf_mul, 1);
+  rb_define_method(cGMP_F, "/", r_gmpf_div, 1);
+  rb_define_method(cGMP_F, "-@", r_gmpf_neg, 0);
+  rb_define_method(cGMP_F, "neg!", r_gmpf_neg_self, 0);
+  rb_define_method(cGMP_F, "abs", r_gmpf_abs, 0);
+  rb_define_method(cGMP_F, "abs!", r_gmpf_abs_self, 0);
+  
+  // Float Comparison
+  rb_define_method(cGMP_F, "<=>", r_gmpf_cmp, 1);
+  rb_define_method(cGMP_F, ">",   r_gmpf_cmp_gt, 1);
+  rb_define_method(cGMP_F, ">=",  r_gmpf_cmp_ge, 1);
+  rb_define_method(cGMP_F, "<",   r_gmpf_cmp_lt, 1);
+  rb_define_method(cGMP_F, "<=",  r_gmpf_cmp_le, 1);
+  rb_define_method(cGMP_F, "==",  r_gmpf_eq, 1);
+  
+  // _unsorted_
+  rb_define_method(cGMP_F, "floor",  r_gmpf_floor, 0);
+  rb_define_method(cGMP_F, "floor!",  r_gmpf_floor_self, 0);
+  rb_define_method(cGMP_F, "ceil",  r_gmpf_ceil, 0);
+  rb_define_method(cGMP_F, "ceil!",  r_gmpf_ceil_self, 0);
+  rb_define_method(cGMP_F, "trunc",  r_gmpf_trunc, 0);
+  rb_define_method(cGMP_F, "trunc!",  r_gmpf_trunc_self, 0);
+  rb_define_method(cGMP_F, "sgn", r_gmpf_sgn, 0);
+  rb_define_method(cGMP_F, "prec", r_gmpf_get_prec, 0);
+}

data/ext/gmpq.c

@@ -0,0 +1,679 @@
+#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.
+ */
+
+/**********************************************************************
+ *    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                                          *
+ **********************************************************************/
+
+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));
+}
+
+
+/**********************************************************************
+ *    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, "Z", r_gmpmod_z, -1);
+  rb_define_module_function(mGMP, "Q", r_gmpmod_q, -1);
+  rb_define_module_function(mGMP, "F", r_gmpmod_f, -1);
+
+  cGMP_Q = rb_define_class_under (mGMP, "Q", rb_cNumeric);
+
+  // Initializing Rationals
+  rb_define_method(cGMP_Q, "swap",  r_gmpq_swap, 1);
+  
+  // Rational Conversions
+  rb_define_method(cGMP_Q, "to_d",  r_gmpq_to_d, 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);
+}