gmp 0.4.7-x86-mingw32 → 0.5.3-x86-mingw32

data/ext/gmpq.c

@@ -156,8 +156,8 @@ VALUE r_gmpq_to_s(VALUE self)
   MP_INT *self_val_num, *self_val_den;
   char *str;
   VALUE res;
-  int sizeinbase;
-  int offset;
+  size_t sizeinbase;
+  size_t offset;
 
   //Data_Get_Struct (self, MP_RAT, self_val);
   mpq_get_struct(self, self_val)
@@ -222,10 +222,14 @@ VALUE r_gmpq_add(VALUE self, VALUE arg)
   } 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_mul_si(res_val_num, mpq_denref(self_val), FIX2NUM(arg));
     mpz_add(res_val_num, res_val_num, mpq_numref(self_val));
   } else if (GMPF_P(arg)) {
+#ifndef MPFR
     return r_gmpf_add(arg,self);
+#else
+    return rb_funcall(arg, rb_intern("+"), 1, self);
+#endif
   } else if (BIGNUM_P(arg)) {
     res_val_num = mpq_numref(res_val);
     mpz_set(mpq_denref(res_val), mpq_denref(self_val));
@@ -255,7 +259,7 @@ VALUE r_gmpq_sub(VALUE self, VALUE arg)
   MP_INT *arg_val_z, *res_val_num;
   MP_FLOAT *arg_val_f, *res_val_f;
   VALUE res;
-  unsigned int prec;
+  mpfr_prec_t prec;
 
   mpq_get_struct(self, self_val);
   mpq_make_struct_init(res, res_val);
@@ -273,7 +277,7 @@ VALUE r_gmpq_sub(VALUE self, VALUE arg)
   } 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_mul_si (res_val_num, mpq_denref(self_val), -FIX2NUM(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);
@@ -329,24 +333,28 @@ VALUE r_gmpq_mul(VALUE self, VALUE arg)
     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));
+    if (FIX2NUM(arg) > 0) {
+      tmp_ui = mpz_gcd_ui(0, mpq_denref(self_val), FIX2NUM(arg));
+    } else if (FIX2NUM(arg) < 0) {
+      tmp_ui = mpz_gcd_ui(0, mpq_denref(self_val), -FIX2NUM(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);
+    mpz_mul_ui(mpq_numref(res_val), mpq_numref(self_val), FIX2NUM(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));
+    mpz_mul_si(mpq_numref(res_val), mpq_numref(self_val), FIX2NUM(arg));
     mpq_canonicalize(res_val);
 #endif
   } else if (GMPF_P(arg)) {
+#ifndef MPFR
     return r_gmpf_mul(arg, self);
+#else
+    return rb_funcall(arg, rb_intern("*"), 1, self);
+#endif
   } else if (BIGNUM_P(arg)) {
     mpz_temp_alloc(tmp_z);
     mpz_set_bignum(tmp_z, arg);
@@ -397,15 +405,15 @@ VALUE r_gmpq_div(VALUE self, VALUE arg)
     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)
+    if (FIX2NUM(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));
+    if (FIX2NUM(arg) > 0) {
+      tmp_ui = mpz_gcd_ui(0, mpq_numref(self_val), FIX2NUM(arg));
     } else {
-      tmp_ui = mpz_gcd_ui(0, mpq_numref(self_val), -FIX2INT(arg));
+      tmp_ui = mpz_gcd_ui(0, mpq_numref(self_val), -FIX2NUM(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);
+    mpz_mul_ui(mpq_denref(res_val), mpq_denref(self_val), FIX2NUM(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);
@@ -557,7 +565,7 @@ int mpq_cmp_value(MP_RAT *OP, VALUE arg)
   } else if (FIXNUM_P(arg)) {
     mpz_temp_alloc(tmp_z);
     mpz_init(tmp_z);
-    mpz_mul_si(tmp_z, mpq_denref(OP), FIX2INT(arg));
+    mpz_mul_si(tmp_z, mpq_denref(OP), FIX2NUM(arg));
     res = mpz_cmp(mpq_numref(OP), tmp_z);
     mpz_temp_free(tmp_z);
     return res;

data/ext/gmpz.c

@@ -19,10 +19,17 @@
  *   to_i           r_gmpz_to_i             mpz_get_i
  *   to_s           r_gmpz_to_s             mpz_get_s
  *   +              r_gmpz_add              mpz_add
+ *   \------------------------              mpz_add_ui
  *   add!           r_gmpz_add_self         mpz_add
+ *   \-----------------------------         mpz_add_ui
  *   -              r_gmpz_sub              mpz_sub
+ *   \------------------------              mpz_sub_ui
  *   sub!           r_gmpz_sub_self         mpz_sub
+ *   \-----------------------------         mpz_sub_ui
  *   *              r_gmpz_mul              mpz_mul
+ *   \------------------------              mpz_mul_si
+ *   addmul!        r_gmpz_addmul_self      mpz_addmul
+ *   \--------------------------------      mpz_addmul_ui
  *   /              r_gmpz_div              ...
  *   tdiv           r_gmpz_tdiv             mpz_tdiv_q
  *   tmod           r_gmpz_tmod             mpz_tdiv_r
@@ -81,12 +88,19 @@
  *   odd?           r_gmpz_is_odd           mpz_odd
  *   sizeinbase     r_gmpz_sizeinbase       mpz_sizeinbase
  *   size_in_bin    r_gmpz_size_in_bin      mpz_sizeinbits
+ *   size           r_gmpz_size             mpz_size
  */
 
 /**********************************************************************
  *    Macros                                                          *
  **********************************************************************/
 
+/*
+ * DEFUN_INT2INT defines two functions. The first takes a GMP::Z as
+ * self, calls mpz_fname on the contained mpz_t, whose arguments are
+ * exactly (0) the return argument and (1) self. The second is the same
+ * destructive method.
+ */
 #define DEFUN_INT2INT(fname,mpz_fname)         \
 static VALUE r_gmpz_##fname(VALUE self)        \
 {                                              \
@@ -106,6 +120,12 @@ static VALUE r_gmpz_##fname##_self(VALUE self) \
   return self;                                 \
 }
 
+/*
+ * DEFUNN_INT_F_UL defines a function that takes a GMP::Z as self,
+ * and a FIXNUM or GMP::Z as exp. It calls mpz_fname on the contained
+ * mpz_t, whose arguments are (0) the return argument, (1) self, and
+ * (2) exp_value. exp must fit into a ulong.
+ */
 #define DEFUN_INT_F_UL(fname,mpz_fname,argname)          \
 static VALUE r_gmpz_##fname(VALUE self, VALUE exp)       \
 {                                                        \
@@ -114,9 +134,9 @@ static VALUE r_gmpz_##fname(VALUE self, VALUE exp)       \
   unsigned long exp_val;                                 \
                                                          \
   if (FIXNUM_P(exp)) {                                   \
-    if (FIX2INT(exp) < 0)                                \
+    if (FIX2NUM(exp) < 0)                                \
       rb_raise(rb_eRangeError, argname " out of range"); \
-    exp_val = FIX2INT(exp);                              \
+    exp_val = FIX2NUM(exp);                              \
   } else if (GMPZ_P(exp)) {                              \
     mpz_get_struct(exp, res_val);                        \
     if (!mpz_fits_ulong_p(res_val))                      \
@@ -148,7 +168,7 @@ static VALUE r_gmpz_##fname(VALUE self, VALUE arg)    \
 {                                                     \
   MP_INT *self_val, *arg_val, *res_val;               \
   VALUE res;                                          \
-  int arg_val_i;                                      \
+  long arg_val_i;                                     \
                                                       \
   mpz_get_struct(self, self_val);                     \
   mpz_make_struct_init(res, res_val);                 \
@@ -159,7 +179,7 @@ static VALUE r_gmpz_##fname(VALUE self, VALUE arg)    \
       rb_raise (rb_eZeroDivError, "divided by 0");    \
     gmp_fname (res_val, self_val, arg_val);           \
   } else if (FIXNUM_P(arg)) {                         \
-    arg_val_i = FIX2INT(arg);                         \
+    arg_val_i = FIX2NUM(arg);                         \
     if (arg_val_i > 0) {                              \
       gmp_fname##_ui (res_val, self_val, arg_val_i);  \
     } else if (arg_val_i == 0) {                      \
@@ -185,50 +205,50 @@ static VALUE r_gmpz_##fname(VALUE self, VALUE arg) \
   MP_INT *self_val, *arg_val, *res_val;            \
   VALUE res;                                       \
                                                    \
-  mpz_get_struct(self, self_val);                  \
+  mpz_get_struct (self, self_val);                 \
                                                    \
-  mpz_make_struct(res, res_val);                   \
-  if (GMPZ_P(arg)) {                               \
-    mpz_get_struct(arg,arg_val);                   \
-    mpz_init(res_val);                             \
-    mpz_fname(res_val, self_val, arg_val);         \
-  } else if (FIXNUM_P(arg)) {                      \
-    mpz_init_set_si(res_val, FIX2INT(arg));        \
-    mpz_fname(res_val, self_val, res_val);         \
-  } else if (BIGNUM_P(arg)) {                      \
-    mpz_init(res_val);                             \
-    mpz_set_bignum(res_val, arg);                  \
-    mpz_fname(res_val, self_val, res_val);         \
+  mpz_make_struct (res, res_val);                  \
+  if (GMPZ_P (arg)) {                              \
+    mpz_get_struct (arg,arg_val);                  \
+    mpz_init (res_val);                            \
+    mpz_fname (res_val, self_val, arg_val);        \
+  } else if (FIXNUM_P (arg)) {                     \
+    mpz_init_set_si (res_val, FIX2NUM (arg));      \
+    mpz_fname (res_val, self_val, res_val);        \
+  } else if (BIGNUM_P (arg)) {                     \
+    mpz_init (res_val);                            \
+    mpz_set_bignum (res_val, arg);                 \
+    mpz_fname (res_val, self_val, res_val);        \
   } else  {                                        \
-    typeerror(ZXB);                                \
+    typeerror (ZXB);                               \
   }                                                \
   return res;                                      \
 }
 
-#define DEFUN_INT_SINGLETON_UI(fname,mpz_fname)           \
-static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg)     \
-{                                                         \
-  MP_INT *arg_val_z, *res_val;                            \
-  unsigned long arg_val_ul;                               \
-  VALUE res;                                              \
-                                                          \
-  (void)klass;                                            \
-                                                          \
-  if (FIXNUM_P(arg)) {                                    \
-    arg_val_ul = FIX2INT (arg);                           \
-  } else if (GMPZ_P(arg)) {                               \
-    mpz_get_struct(arg, arg_val_z);                       \
-    if (!mpz_fits_ulong_p (arg_val_z))                    \
-      rb_raise(rb_eRangeError, "argument out of range");  \
-    arg_val_ul = mpz_get_ui(arg_val_z);                   \
-    if (arg_val_ul == 0)                                  \
-      rb_raise(rb_eRangeError, "argument out of range");  \
-  } else {                                                \
-    typeerror_as(ZX, "argument");                         \
-  }                                                       \
-  mpz_make_struct_init(res, res_val);                     \
-  mpz_fname(res_val, arg_val_ul);                         \
-  return res;                                             \
+#define DEFUN_INT_SINGLETON_UI(fname,mpz_fname)              \
+static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg)        \
+{                                                            \
+  MP_INT *arg_val_z, *res_val;                               \
+  unsigned long arg_val_ul;                                  \
+  VALUE res;                                                 \
+                                                             \
+  (void)klass;                                               \
+                                                             \
+  if (FIXNUM_P (arg)) {                                      \
+    arg_val_ul = FIX2NUM (arg);                              \
+  } else if (GMPZ_P (arg)) {                                 \
+    mpz_get_struct (arg, arg_val_z);                         \
+    if (!mpz_fits_ulong_p (arg_val_z))                       \
+      rb_raise (rb_eRangeError, "argument out of range");    \
+    arg_val_ul = mpz_get_ui (arg_val_z);                     \
+    if (arg_val_ul == 0)                                     \
+      rb_raise (rb_eRangeError, "argument out of range");    \
+  } else {                                                   \
+    typeerror_as (ZX, "argument");                           \
+  }                                                          \
+  mpz_make_struct_init (res, res_val);                       \
+  mpz_fname (res_val, arg_val_ul);                           \
+  return res;                                                \
 }
 
 /**********************************************************************
@@ -289,9 +309,9 @@ void mpz_set_value(MP_INT *target, VALUE source)
     mpz_get_struct(source, source_val);
     mpz_set(target, source_val);
   } else if (FIXNUM_P(source)) {
-    mpz_set_si(target, NUM2INT(source));
+    mpz_set_si(target, FIX2NUM(source));
   } else if (STRING_P(source)) {
-    mpz_set_str(target, STR2CSTR(source), 0);
+    mpz_set_str(target, StringValuePtr(source), 0);
   } else if (BIGNUM_P(source)) {
     mpz_set_bignum(target, source);
   } else {
@@ -482,14 +502,18 @@ VALUE r_gmpz_add(VALUE self, VALUE arg)
     mpz_add(res_val, self_val, arg_val);
   } else if (FIXNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
-    if (FIX2INT(arg) > 0)
-      mpz_add_ui(res_val, self_val, FIX2INT(arg));
+    if (FIX2NUM(arg) > 0)
+      mpz_add_ui(res_val, self_val, FIX2NUM(arg));
     else
-      mpz_sub_ui(res_val, self_val, -FIX2INT(arg));
+      mpz_sub_ui(res_val, self_val, -FIX2NUM(arg));
   } else if (GMPQ_P(arg)) {
     return r_gmpq_add(arg, self);
   } else if (GMPF_P(arg)) {
+#ifndef MPFR
     return r_gmpf_add(arg, self);
+#else
+    return rb_funcall(arg, rb_intern("+"), 1, self);
+#endif
   } else if (BIGNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
     mpz_init(res_val);
@@ -523,10 +547,10 @@ VALUE r_gmpz_add_self(VALUE self, VALUE arg)
     mpz_get_struct(arg,arg_val);
     mpz_add(self_val, self_val, arg_val);
   } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) > 0)
-      mpz_add_ui(self_val, self_val, FIX2INT(arg));
+    if (FIX2NUM(arg) > 0)
+      mpz_add_ui(self_val, self_val, FIX2NUM(arg));
     else
-      mpz_sub_ui(self_val, self_val, -FIX2INT(arg));
+      mpz_sub_ui(self_val, self_val, -FIX2NUM(arg));
   } else if (BIGNUM_P(arg)) {
     mpz_temp_from_bignum(arg_val, arg);
     mpz_add(self_val, self_val, arg_val);
@@ -564,10 +588,10 @@ VALUE r_gmpz_sub(VALUE self, VALUE arg)
     mpz_sub (res_val, self_val, arg_val);
   } else if (FIXNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
-    if (FIX2INT(arg) > 0)
-      mpz_sub_ui (res_val, self_val, FIX2INT(arg));
+    if (FIX2NUM(arg) > 0)
+      mpz_sub_ui (res_val, self_val, FIX2NUM(arg));
     else
-      mpz_add_ui (res_val, self_val, -FIX2INT(arg));
+      mpz_add_ui (res_val, self_val, -FIX2NUM(arg));
   } else if (GMPQ_P(arg)) {
     mpq_make_struct_init(res, res_val_q);
     mpq_get_struct(arg,arg_val_q);
@@ -611,10 +635,10 @@ VALUE r_gmpz_sub_self(VALUE self, VALUE arg)
     mpz_get_struct(arg, arg_val);
     mpz_sub (self_val, self_val, arg_val);
   } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) > 0)
-      mpz_sub_ui (self_val, self_val, FIX2INT(arg));
+    if (FIX2NUM(arg) > 0)
+      mpz_sub_ui (self_val, self_val, FIX2NUM(arg));
     else
-      mpz_add_ui (self_val, self_val, -FIX2INT(arg));
+      mpz_add_ui (self_val, self_val, -FIX2NUM(arg));
   } else if (BIGNUM_P(arg)) {
     mpz_temp_from_bignum(arg_val, arg);
     mpz_sub (self_val, self_val, arg_val);
@@ -649,11 +673,15 @@ VALUE r_gmpz_mul(VALUE self, VALUE arg)
     mpz_mul(res_val, self_val, arg_val);
   } else if (FIXNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
-    mpz_mul_si(res_val, self_val, FIX2INT(arg));
+    mpz_mul_si(res_val, self_val, FIX2NUM(arg));
   } else if (GMPQ_P(arg)) {
     return r_gmpq_mul(arg, self);
   } else if (GMPF_P(arg)) {
+#ifndef MPFR
     return r_gmpf_mul(arg, self);
+#else
+    return rb_funcall(arg, rb_intern("*"), 1, self);
+#endif
   } else if (BIGNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
     mpz_set_bignum(res_val, arg);
@@ -664,6 +692,57 @@ VALUE r_gmpz_mul(VALUE self, VALUE arg)
   return res;
 }
 
+/*
+ * call-seq:
+ *   a.addmul!(b, c)
+ *
+ * From the GMP Manual:
+ * 
+ * Sets +a+ to +a+ plus +b+ times +c+.
+ */
+VALUE r_gmpz_addmul_self(VALUE self, VALUE b, VALUE c)
+{
+  MP_INT *self_val, *b_val, *c_val;
+  int free_b_val = 0;
+
+  if (GMPZ_P(b)) {
+    mpz_get_struct(b, b_val);
+  } else if (FIXNUM_P(b)) {
+    mpz_temp_alloc(b_val);
+    mpz_init_set_si(b_val, FIX2NUM(b));
+    free_b_val = 1;
+  } else if (BIGNUM_P(b)) {
+    mpz_temp_from_bignum(b_val, b);
+    free_b_val = 1;
+  } else {
+    typeerror_as(ZXB, "addend");
+  }
+  mpz_get_struct(self, self_val);
+
+  if (GMPZ_P(c)) {
+    mpz_get_struct(c, c_val);
+    mpz_addmul(self_val, b_val, c_val);
+  } else if (FIXNUM_P(c)) {
+    if (FIX2NUM(c) < 0)
+    {
+      if (free_b_val) { mpz_temp_free(b_val); }
+      rb_raise(rb_eRangeError, "multiplicand (Fixnum) must be nonnegative");
+    }
+    mpz_addmul_ui(self_val, b_val, FIX2NUM(c));
+  } else if (BIGNUM_P(c)) {
+    mpz_temp_from_bignum(c_val, c);
+    mpz_addmul(self_val, b_val, c_val);
+    mpz_temp_free(c_val);
+  } else {
+    if (free_b_val)
+      mpz_temp_free(b_val);
+    typeerror_as(ZXB, "multiplicand");
+  }
+  if (free_b_val)
+    mpz_temp_free(b_val);
+  return self;
+}
+
 /*
  * Document-method: <<
  *
@@ -746,7 +825,11 @@ VALUE r_gmpz_div(VALUE self, VALUE arg)
   MP_RAT *arg_val_q, *res_val_q;
   MP_FLOAT *arg_val_f, *res_val_f;
   VALUE res;
+#if defined(MPFR) && MPFR_VERSION_MAJOR>2
+  mpfr_prec_t prec;
+#else
   unsigned int prec;
+#endif
 
   mpz_get_struct (self,self_val);
 
@@ -759,11 +842,11 @@ VALUE r_gmpz_div(VALUE self, VALUE arg)
     mpq_set_den (res_val_q, arg_val_z);
     mpq_canonicalize (res_val_q);
   } else if (FIXNUM_P (arg)) {
-    if (FIX2INT (arg) == 0)
+    if (FIX2NUM (arg) == 0)
       rb_raise (rb_eZeroDivError, "divided by 0");
     mpq_make_struct_init (res, res_val_q);
     mpq_set_num (res_val_q, self_val);
-    mpz_set_ui (mpq_denref (res_val_q), FIX2INT (arg));
+    mpz_set_ui (mpq_denref (res_val_q), FIX2NUM (arg));
     mpq_canonicalize (res_val_q);
   } else if (GMPQ_P (arg)) {
     mpq_get_struct (arg, arg_val_q);
@@ -922,7 +1005,7 @@ VALUE r_gmpz_mod(VALUE self, VALUE arg)
     mpz_mod(res_val, self_val, arg_val);
   } else if (FIXNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
-    mpz_mod_ui(res_val, self_val, FIX2INT(arg));
+    mpz_mod_ui(res_val, self_val, FIX2NUM(arg));
   } else if (BIGNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
     mpz_set_bignum(res_val, arg);
@@ -974,11 +1057,11 @@ VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod)
       rb_raise(rb_eRangeError, "modulus must be positive");
     }
   } else if (FIXNUM_P(mod)) {
-    if (FIX2INT(mod) <= 0) {
+    if (FIX2NUM(mod) <= 0) {
       rb_raise(rb_eRangeError, "modulus must be positive");
     }
     mpz_temp_alloc(mod_val);
-    mpz_init_set_ui(mod_val, FIX2INT(mod));
+    mpz_init_set_ui(mod_val, FIX2NUM(mod));
     free_mod_val = 1;
   } else if (BIGNUM_P(mod)) {
     mpz_temp_from_bignum(mod_val, mod);
@@ -1000,13 +1083,13 @@ VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod)
     }
     mpz_powm(res_val, self_val, exp_val, mod_val);
   } else if (FIXNUM_P(exp)) {
-    if (FIX2INT(exp) < 0)
+    if (FIX2NUM(exp) < 0)
     {
       if (free_mod_val)
         mpz_temp_free(mod_val);
       rb_raise(rb_eRangeError, "exponent must be nonnegative");
     }
-    mpz_powm_ui(res_val, self_val, FIX2INT(exp), mod_val);
+    mpz_powm_ui(res_val, self_val, FIX2NUM(exp), mod_val);
   } else if (BIGNUM_P(exp)) {
     mpz_temp_from_bignum(exp_val, exp);
     mpz_powm(res_val, self_val, exp_val, mod_val);
@@ -1141,17 +1224,17 @@ VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self)
   MP_INT *self_val;
   int reps_val;
   VALUE reps;
-  mpz_get_struct(self, self_val);
-  rb_scan_args(argc, argv, "01", &reps);
+  mpz_get_struct (self, self_val);
+  rb_scan_args (argc, argv, "01", &reps);
   if(NIL_P(reps)){
-    reps = INT2FIX(5);
+    reps = INT2FIX (5);
   }
-  if (FIXNUM_P(reps)) {
+  if (FIXNUM_P (reps)) {
     reps_val = FIX2INT (reps);
   } else {
-    typeerror_as(X, "reps");
+    typeerror_as (X, "reps");
   }
-  return INT2FIX(mpz_probab_prime_p(self_val, reps_val));
+  return INT2FIX (mpz_probab_prime_p(self_val, reps_val));
 }
 
 /*
@@ -1199,7 +1282,7 @@ VALUE r_gmpz_gcd(VALUE self, VALUE arg)
     mpz_gcd (res_val, self_val, arg_val);
   } else if (FIXNUM_P (arg)) {
     mpz_make_struct_init (res, res_val);
-    mpz_gcd_ui (res_val, self_val, FIX2INT(arg));
+    mpz_gcd_ui (res_val, self_val, FIX2NUM(arg));
   } else if (BIGNUM_P (arg)) {
     mpz_make_struct_init (res, res_val);
     mpz_set_bignum (res_val, arg);
@@ -1223,7 +1306,7 @@ VALUE r_gmpz_invert(VALUE self, VALUE arg)
     mpz_invert (res_val, self_val, arg_val);
   } else if (FIXNUM_P (arg)) {
     mpz_temp_alloc(arg_val);
-    mpz_init_set_ui(arg_val, FIX2INT(arg));
+    mpz_init_set_ui(arg_val, FIX2NUM(arg));
     mpz_make_struct_init (res, res_val);
     mpz_invert (res_val, self_val, arg_val);
   } else if (BIGNUM_P (arg)) {
@@ -1284,7 +1367,7 @@ VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b)
     mpz_get_struct(a, a_val);
   } else if (FIXNUM_P(a)) {
     mpz_temp_alloc(a_val);
-    mpz_init_set_ui(a_val, FIX2INT(a));
+    mpz_init_set_ui(a_val, FIX2NUM(a));
     free_a_val = 1;
   } else if (BIGNUM_P(a)) {
     mpz_temp_from_bignum(a_val, a);
@@ -1300,12 +1383,12 @@ VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b)
     if (mpz_even_p(b_val))
       rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is even.");
   } else if (FIXNUM_P(b)) {
-    if (FIX2INT(b) <= 0)
+    if (FIX2NUM(b) <= 0)
       rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is non-positive.");
-    if (FIX2INT(b) % 2 == 0)
+    if (FIX2NUM(b) % 2 == 0)
       rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is even.");
     mpz_temp_alloc(b_val);
-    mpz_init_set_ui(b_val, FIX2INT(b));
+    mpz_init_set_ui(b_val, FIX2NUM(b));
     free_b_val = 1;
   } else if (BIGNUM_P(b)) {
     mpz_temp_from_bignum(b_val, b);
@@ -1370,7 +1453,11 @@ VALUE r_gmpz_remove(VALUE self, VALUE arg)
 {
   MP_INT *self_val, *arg_val, *res_val;
   VALUE res;
+#if __GNU_MP_VERSION>2
+  unsigned long removed_val;
+#else
   int   removed_val;
+#endif
   int free_arg_val = 0;
 
   mpz_get_struct(self, self_val);
@@ -1380,10 +1467,10 @@ VALUE r_gmpz_remove(VALUE self, VALUE arg)
     if (mpz_sgn(arg_val) != 1)
       rb_raise(rb_eRangeError, "argument must be positive");
   } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) <= 0)
+    if (FIX2NUM(arg) <= 0)
       rb_raise(rb_eRangeError, "argument must be positive");
     mpz_temp_alloc(arg_val);
-    mpz_init_set_ui(arg_val, FIX2INT(arg));
+    mpz_init_set_ui(arg_val, FIX2NUM(arg));
   } else if (BIGNUM_P(arg)) {
     mpz_temp_from_bignum(arg_val, arg);
     if (mpz_sgn(arg_val) != 1) {
@@ -1459,7 +1546,7 @@ VALUE r_gmpz_eq(VALUE self, VALUE arg)
     mpz_get_struct(arg, arg_val_z);
     return (mpz_cmp (self_val, arg_val_z)==0) ? Qtrue : Qfalse;
   } else if (FIXNUM_P(arg)) {
-    return (mpz_cmp_si (self_val, FIX2INT(arg))==0) ? Qtrue : Qfalse;
+    return (mpz_cmp_si (self_val, FIX2NUM(arg))==0) ? Qtrue : Qfalse;
   } else if (GMPQ_P(arg)) {
     mpq_get_struct(arg, arg_val_q);
     if (mpz_cmp_ui(mpq_denref(arg_val_q), 1)==0)
@@ -1489,7 +1576,7 @@ int mpz_cmp_value(MP_INT *OP, VALUE arg)
     mpz_get_struct(arg,arg_val_z);
     return mpz_cmp(OP,arg_val_z);
   } else if (FIXNUM_P(arg)) {
-    return mpz_cmp_si(OP, FIX2INT(arg));
+    return mpz_cmp_si(OP, FIX2NUM(arg));
   } else if (GMPQ_P(arg)) {
     mpq_get_struct(arg,arg_val_q);
     mpz_temp_alloc(arg_val_z);
@@ -1573,10 +1660,10 @@ VALUE r_gmpz_cmpabs(VALUE self, VALUE arg)
     mpz_get_struct(arg,arg_val_z);
     return INT2FIX(mpz_cmpabs(self_val, arg_val_z));
   } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) >= 0)
-      return INT2FIX(mpz_cmpabs_ui(self_val, FIX2INT(arg)));
+    if (FIX2NUM(arg) >= 0)
+      return INT2FIX(mpz_cmpabs_ui(self_val, FIX2NUM(arg)));
     else
-      return INT2FIX(mpz_cmpabs_ui(self_val, -FIX2INT(arg)));
+      return INT2FIX(mpz_cmpabs_ui(self_val, -FIX2NUM(arg)));
   } else if (GMPQ_P(arg)) {
     mpq_get_struct(arg,arg_val_q);
     mpz_temp_alloc(arg_val_z);
@@ -1738,13 +1825,13 @@ VALUE r_gmpz_scan0(VALUE self, VALUE bitnr)
 {
   MP_INT *self_val;
   int bitnr_val;
-  mpz_get_struct(self, self_val);
-  if (FIXNUM_P(bitnr)) {
+  mpz_get_struct (self, self_val);
+  if (FIXNUM_P (bitnr)) {
     bitnr_val = FIX2INT (bitnr);
   } else {
-    typeerror_as(X, "index");
+    typeerror_as (X, "index");
   }
-  return INT2FIX(mpz_scan0(self_val, bitnr_val));
+  return INT2FIX (mpz_scan0 (self_val, bitnr_val));
 }
 
 /*
@@ -1767,15 +1854,15 @@ VALUE r_gmpz_scan1(VALUE self, VALUE bitnr)
   MP_INT *self_val;
   int bitnr_val;
 
-  mpz_get_struct(self, self_val);
+  mpz_get_struct (self, self_val);
 
-  if (FIXNUM_P(bitnr)) {
+  if (FIXNUM_P (bitnr)) {
     bitnr_val = FIX2INT (bitnr);
   } else {
-    typeerror_as(X, "index");
+    typeerror_as (X, "index");
   }
 
-  return INT2FIX(mpz_scan1(self_val, bitnr_val));
+  return INT2FIX (mpz_scan1 (self_val, bitnr_val));
 }
 
 /*
@@ -1787,12 +1874,15 @@ VALUE r_gmpz_scan1(VALUE self, VALUE bitnr)
 VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to)
 {
   MP_INT *self_val;
-  int bitnr_val;
+  unsigned long bitnr_val;
 
   mpz_get_struct (self, self_val);
 
   if (FIXNUM_P (bitnr)) {
-    bitnr_val = FIX2INT (bitnr);
+    if (FIX2NUM (bitnr) < 0) {
+      rb_raise(rb_eRangeError, "index must be nonnegative");
+    }
+    bitnr_val = FIX2NUM (bitnr);
   } else {
     typeerror_as (X, "index");
   }
@@ -1813,10 +1903,10 @@ VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to)
 VALUE r_gmpz_getbit(VALUE self, VALUE bitnr)
 {
   MP_INT *self_val;
-  int bitnr_val;
+  unsigned long bitnr_val;
   mpz_get_struct(self, self_val);
   if (FIXNUM_P(bitnr)) {
-    bitnr_val = FIX2INT (bitnr);
+    bitnr_val = FIX2NUM (bitnr);
   } else {
     typeerror_as(X, "index");
   }
@@ -1872,6 +1962,24 @@ VALUE r_gmpz_size_in_bin(VALUE self)
  *    Integer Special Functions                                       *
  **********************************************************************/
 
+/*
+ * Document-method: size
+ *
+ * call-seq:
+ *   integer.size
+ *
+ * From the GMP Manual:
+ * 
+ * Return the size of <tt>integer</tt> measured in number of limbs. If
+ * <tt>integer</tt> is zero, the returned value will be zero. 
+ */
+VALUE r_gmpz_size(VALUE self)
+{
+  MP_INT *self_val;
+  mpz_get_struct(self, self_val);
+  return INT2FIX(mpz_size(self_val));
+}
+
 
 /**********************************************************************
  *    _unsorted_                                                      *
@@ -1889,12 +1997,12 @@ VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp)
 
   if (FIXNUM_P(base) && FIXNUM_P(exp))
   {
-    if (FIX2INT(base) < 0)
+    if (FIX2NUM(base) < 0)
       rb_raise (rb_eRangeError, "base must not be negative");
-    if (FIX2INT(exp) < 0) 
+    if (FIX2NUM(exp) < 0) 
       rb_raise (rb_eRangeError, "exponent must not be negative");
     mpz_make_struct_init (res, res_val);
-    mpz_ui_pow_ui (res_val, base, exp);
+    mpz_ui_pow_ui (res_val, FIX2NUM(base), FIX2NUM(exp));
     return res;
   }
   return r_gmpz_pow (r_gmpzsg_new(1, &base, klass), exp);
@@ -1918,17 +2026,18 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "to_s", r_gmpz_to_s, -1);
   
   // Integer Arithmetic
-  rb_define_method(cGMP_Z, "+",    r_gmpz_add, 1);
-  rb_define_method(cGMP_Z, "add!", r_gmpz_add_self, 1);
-  rb_define_method(cGMP_Z, "-",    r_gmpz_sub, 1);  
-  rb_define_method(cGMP_Z, "sub!", r_gmpz_sub_self, 1);
-  rb_define_method(cGMP_Z, "*",    r_gmpz_mul, 1);
-  rb_define_method(cGMP_Z, "<<",   r_gmpz_shl, 1);
-  rb_define_method(cGMP_Z, "neg",  r_gmpz_neg, 0);
-  rb_define_method(cGMP_Z, "neg!", r_gmpz_neg_self, 0);
-  rb_define_method(cGMP_Z, "-@",   r_gmpz_neg, 0);
-  rb_define_method(cGMP_Z, "abs",  r_gmpz_abs, 0);
-  rb_define_method(cGMP_Z, "abs!", r_gmpz_abs_self, 0);
+  rb_define_method(cGMP_Z, "+",       r_gmpz_add, 1);
+  rb_define_method(cGMP_Z, "add!",    r_gmpz_add_self, 1);
+  rb_define_method(cGMP_Z, "-",       r_gmpz_sub, 1);  
+  rb_define_method(cGMP_Z, "sub!",    r_gmpz_sub_self, 1);
+  rb_define_method(cGMP_Z, "*",       r_gmpz_mul, 1);
+  rb_define_method(cGMP_Z, "addmul!", r_gmpz_addmul_self, 2);
+  rb_define_method(cGMP_Z, "<<",      r_gmpz_shl, 1);
+  rb_define_method(cGMP_Z, "neg",     r_gmpz_neg, 0);
+  rb_define_method(cGMP_Z, "neg!",    r_gmpz_neg_self, 0);
+  rb_define_method(cGMP_Z, "-@",      r_gmpz_neg, 0);
+  rb_define_method(cGMP_Z, "abs",     r_gmpz_abs, 0);
+  rb_define_method(cGMP_Z, "abs!",    r_gmpz_abs_self, 0);
   
   // Integer Division
   rb_define_method(cGMP_Z, "/",    r_gmpz_div, 1);
@@ -1982,24 +2091,27 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "hash",    r_gmpz_hash, 0);
   
   // Integer Logic and Bit Fiddling
-  rb_define_method(cGMP_Z, "&", r_gmpz_and, 1);
-  rb_define_method(cGMP_Z, "|", r_gmpz_or, 1);
-  rb_define_method(cGMP_Z, "^", r_gmpz_xor, 1);
-  rb_define_method(cGMP_Z, "com", r_gmpz_com, 0);
-  rb_define_method(cGMP_Z, "com!", r_gmpz_com_self, 0);
-  rb_define_method(cGMP_Z, "popcount",  r_gmpz_popcount, 0);
-  rb_define_method(cGMP_Z, "scan0", r_gmpz_scan0, 1);
-  rb_define_method(cGMP_Z, "scan1", r_gmpz_scan1, 1);
-  rb_define_method(cGMP_Z, "[]=", r_gmpz_setbit, 2);
-  rb_define_method(cGMP_Z, "[]", r_gmpz_getbit, 1);
+  rb_define_method(cGMP_Z, "&",        r_gmpz_and, 1);
+  rb_define_method(cGMP_Z, "|",        r_gmpz_or, 1);
+  rb_define_method(cGMP_Z, "^",        r_gmpz_xor, 1);
+  rb_define_method(cGMP_Z, "com",      r_gmpz_com, 0);
+  rb_define_method(cGMP_Z, "com!",     r_gmpz_com_self, 0);
+  rb_define_method(cGMP_Z, "popcount", r_gmpz_popcount, 0);
+  rb_define_method(cGMP_Z, "scan0",    r_gmpz_scan0, 1);
+  rb_define_method(cGMP_Z, "scan1",    r_gmpz_scan1, 1);
+  rb_define_method(cGMP_Z, "[]=",      r_gmpz_setbit, 2);
+  rb_define_method(cGMP_Z, "[]",       r_gmpz_getbit, 1);
   
-  //Miscellaneous Integer Functions
+  // Miscellaneous Integer Functions
   rb_define_method(cGMP_Z, "even?", r_gmpz_is_even, 0);
   rb_define_method(cGMP_Z, "odd?", r_gmpz_is_odd, 0);
   rb_define_method(cGMP_Z, "sizeinbase", r_gmpz_sizeinbase, 1);
   rb_define_alias( cGMP_Z, "size_in_base", "sizeinbase");
   rb_define_method(cGMP_Z, "size_in_bin", r_gmpz_size_in_bin, 0);
   
+  // Integer Special Functions
+  rb_define_method(cGMP_Z, "size", r_gmpz_size, 0);
+  
   // _unsorted_
   rb_define_method(cGMP_Z, ">>",  r_gmpz_fshr, 1);
   rb_define_method(cGMP_Z, "tshr",  r_gmpz_tshr, 1);