gmp 0.5.3-x86-mingw32 → 0.5.23-x86-mingw32

data/ext/gmpq.c

@@ -7,25 +7,9 @@
  *
  * 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
+ * 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.
  */
 
 /**********************************************************************
@@ -53,6 +37,30 @@ static VALUE r_gmpq_##fname(VALUE self)                           \
   return res;                                                     \
 }
 
+/*
+ * DEFUN_RAT2RAT defines two functions. The first takes a GMP::Q as self, calls mpq_fname
+ * on the contained mpq_t, whose arguments are exactly (0) the return argument and (1)
+ * self. The second is the same destructive method.
+ */
+#define DEFUN_RAT2RAT(fname,mpq_fname)         \
+static VALUE r_gmpq_##fname(VALUE self)        \
+{                                              \
+  MP_RAT *self_val, *res_val;                  \
+  VALUE res;                                   \
+  mpq_get_struct(self, self_val);              \
+  mpq_make_struct_init(res, res_val);          \
+  mpq_fname(res_val, self_val);                \
+  return res;                                  \
+}                                              \
+                                               \
+static VALUE r_gmpq_##fname##_self(VALUE self) \
+{                                              \
+  MP_RAT *self_val;                            \
+  mpq_get_struct(self, self_val);              \
+  mpq_fname(self_val, self_val);               \
+  return self;                                 \
+}
+
 
 /**********************************************************************
  *    Initializing Rationals                                          *
@@ -62,7 +70,7 @@ static VALUE r_gmpq_##fname(VALUE self)                           \
  * call-seq:
  *   GMP::Q.new(arg)
  *
- * Creates a new GMP::Q rational, with arg as its value, converting where
+ * Creates a new GMP::Q rational, with _arg_ as its value, converting where
  * necessary.
  */
 VALUE r_gmpqsg_new(int argc, VALUE *argv, VALUE klass)
@@ -86,7 +94,7 @@ VALUE r_gmpqsg_new(int argc, VALUE *argv, VALUE klass)
  * call-seq:
  *   GMP::Q(arg)
  *
- * A convenience method for +GMP::Q.new(arg)+.
+ * A convenience method for GMP::Q.new(arg).
  */
 VALUE r_gmpmod_q(int argc, VALUE *argv, VALUE module)
 {
@@ -96,9 +104,9 @@ VALUE r_gmpmod_q(int argc, VALUE *argv, VALUE module)
 
 /*
  * call-seq:
- *   rat1.swap rat2
+ *   p.swap(q)
  *
- * Efficiently swaps the contents of +rat1+ with +rat2+.
+ * Efficiently swaps the contents of _p_ with _q_.
  */
 VALUE r_gmpq_swap(VALUE self, VALUE arg)
 {
@@ -122,17 +130,16 @@ VALUE r_gmpq_swap(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   rational.to_d
+ *   p.to_d
  *
- * Returns +rational+ as an Float if +rational+ fits in a Float.
+ * Returns _p_ as an Float if _p_ fits in a Float.
  *
- * Otherwise returns the least significant part of +rational+, with the same
- * sign as +rational+.
+ * Otherwise returns the least significant part of _p_, with the same sign as _p_.
  *
- * 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. 
+ * 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)
 {
@@ -143,12 +150,10 @@ VALUE r_gmpq_to_d(VALUE self)
 }
 
 /*
- * Document-method: to_s
- *
  * call-seq:
- *   rational.to_s
+ *   p.to_s
  *
- * Returns the decimal representation of +rational+, as a Ruby string.
+ * Returns the decimal representation of _p_, as a String.
  */
 VALUE r_gmpq_to_s(VALUE self)
 {
@@ -192,9 +197,9 @@ VALUE r_gmpq_to_s(VALUE self)
 
 /*
  * call-seq:
- *   rat1 + rat2
+ *   p + q
  *
- * Adds +rat1+ to +rat2+. +rat2+ can be
+ * Adds _p_ to _q_. _q_ must be an instance of one of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -244,9 +249,9 @@ VALUE r_gmpq_add(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   rat1 - rat2
+ *   p - q
  *
- * Subtracts +rat2+ from +rat1+. +rat2+ can be
+ * Subtracts _p_ from _q_. _q_ must be an instance of one of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -299,9 +304,9 @@ VALUE r_gmpq_sub(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   rat1 * rat2
+ *   p * q
  *
- * Multiplies +rat1+ with +rat2+. +rat2+ can be
+ * Multiplies _p_ with _q_. _q_ must be an instance of one of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -371,9 +376,9 @@ VALUE r_gmpq_mul(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   rat1 / rat2
+ *   p / q
  *
- * Divides +rat1+ by +rat2+. +rat2+ can be
+ * Divides _p_ by _q_. _q_ must be an instance of one of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -441,81 +446,41 @@ DEFUN_RAT2INT(ceil,mpz_cdiv_q)
  * Document-method: neg
  *
  * call-seq:
- *   -rational
- *   rational.neg
+ *   a.neg
+ *   -a
  *
- * From the GMP Manual:
- * 
- * Returns -+rational+.
+ * Returns -_a_.
  */
-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!
+ *   a.neg!
  *
- * From the GMP Manual:
- * 
- * Sets +rational+ to -+rational+.
+ * Sets _a_ to -_a_.
  */
-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;
-}
+DEFUN_RAT2RAT(neg, mpq_neg)
 
 /*
- * Document-method: abs
+ * call-seq:
+ *   p.abs
  *
+ * Returns the absolute value of _p_.
+ */
+/*
  * call-seq:
- *   rational.abs
+ *   p.abs!
  *
- * From the GMP Manual:
- * 
- * Returns the absolute value of +rational+.
+ * Sets _p_ to its absolute value.
  */
-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;
-}
+DEFUN_RAT2RAT(abs, mpq_abs)
 
 /*
- * Document-method: abs!
- *
  * call-seq:
- *   rational.abs!
+ *   p.inv
  *
- * From the GMP Manual:
- * 
- * Sets +rational+ to its absolute value.
+ * Returns 1/<i>p</i>.
  */
-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;
@@ -530,6 +495,12 @@ VALUE r_gmpq_inv(VALUE self)
   return res;
 }
 
+/*
+ * call-seq:
+ *   p.inv!
+ *
+ * Sets _p_ to 1/<i>p</i>.
+ */
 VALUE r_gmpq_inv_self(VALUE self)
 {
   MP_RAT *self_val;
@@ -704,11 +675,9 @@ static VALUE r_gmpq_cmpabs(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   rational.sgn
+ *   p.sgn
  *
- * From the GMP Manual:
- * 
- * Returns +1 if +rational+ > 0, 0 if +rational+ == 0, and -1 if +rational+ < 0.
+ * Returns +1 if _p_ > 0, 0 if _p_ == 0, and -1 if _p_ < 0.
  */
 VALUE r_gmpq_sgn(VALUE self)
 {
@@ -761,16 +730,17 @@ void init_gmpq()
   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, "+",    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_alias( cGMP_Q, "neg",  "-@");
   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, 0);
   rb_define_method(cGMP_Q, "abs!", r_gmpq_abs_self, 0);
+  rb_define_method(cGMP_Q, "inv",  r_gmpq_inv, 0);
+  rb_define_method(cGMP_Q, "inv!", r_gmpq_inv_self, 0);
 
   // Comparing Rationals
   rb_define_method(cGMP_Q, "<=>", r_gmpq_cmp, 1);

data/ext/gmprandstate.c

@@ -242,6 +242,35 @@ VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg)
   return res;
 }
 
+/*
+ * call-seq:
+ *   rand_state.rrandomb(fixnum)
+ *
+ * From the GMP Manual:
+ *
+ * Generate a random integer with long strings of zeros and ones in the binary
+ * representation. Useful for testing functions and algorithms, since this kind
+ * of random numbers have proven to be more likely to trigger corner-case bugs.
+ * The random number will be in the range 0 to 2^n-1, inclusive. 
+ */
+VALUE r_gmprandstate_rrandomb(VALUE self, VALUE arg)
+{
+  MP_RANDSTATE *self_val;
+  MP_INT *res_val;
+  VALUE res;
+
+  mprandstate_get_struct(self,self_val);
+  
+  if (FIXNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_rrandomb(res_val, self_val, FIX2INT(arg));
+  } else {
+    typeerror(X);
+  }
+  
+  return res;
+}
+
 
 #ifdef MPFR
 /**********************************************************************
@@ -307,6 +336,7 @@ void init_gmprandstate()
   // Integer Random Numbers
   rb_define_method(cGMP_RandState, "urandomb", r_gmprandstate_urandomb, 1);
   rb_define_method(cGMP_RandState, "urandomm", r_gmprandstate_urandomm, 1);
+  rb_define_method(cGMP_RandState, "rrandomb", r_gmprandstate_rrandomb, 1);
   
 #ifdef MPFR
   // Float Random Numbers

data/ext/gmpz.c

@@ -10,85 +10,6 @@
  * Instances of this class can store variables of the type mpz_t. This class
  * also contains many methods that act as the functions for mpz_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_gmpz_to_d             mpz_get_d
- *   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
- *   fdiv           r_gmpz_fdiv             mpz_fdiv_q
- *   fmod           r_gmpz_fmod             mpz_fdiv_r
- *   cdiv           r_gmpz_cdiv             mpz_cdiv_q
- *   cmod           r_gmpz_cmod             mpz_cdiv_r
- *   %              r_gmpz_mod              mpz_mod
- *   \------------------------              mpz_mod_ui
- *   -@             r_gmpz_neg              mpz_neg
- *   neg            r_gmpz_neg              mpz_neg
- *   neg!           r_gmpz_neg_self         mpz_neg
- *   abs            r_gmpz_abs              mpz_abs
- *   abs!           r_gmpz_abs_self         mpz_abs
- *   **             r_gmpz_pow              mpz_pow_ui
- *   powmod         r_gmpz_powm             mpz_powm
- *   root           r_gmpz_root             mpz_root
- *   sqrt           r_gmpz_sqrt             mpz_sqrt
- *   sqrt!          r_gmpz_sqrt_self        mpz_sqrt
- *   sqrtrem        r_gmpz_sqrtrem          mpz_sqrtrem
- *   power?         r_gmpz_is_power         mpz_perfect_power_p
- *   square?        r_gmpz_is_square        mpz_perfect_square_p
- *   probab_prime?  r_gmpz_is_probab_prime  mpz_probab_prime_p
- *   nextprime      r_gmpz_nextprime        mpz_nextprime
- *   nextprime!     r_gmpz_nextprime_self   mpz_nextprime
- *   gcd            r_gmpz_gcd              mpz_gcd
- *   \------------------------              mpz_gcd_ui
- *   invert         r_gmpz_invert           mpz_invert
- *   jacobi         r_gmpz_jacobi           mpz_jacobi
- *   #jacobi        r_gmpzsg_jacobi         mpz_jacobi
- *   legendre       r_gmpz_legendre         mpz_legendre
- *   remove         r_gmpz_remove           mpz_remove
- *   fac            r_gmpz_fac              mpz_fac_ui
- *   fib            r_gmpz_fib              mpz_fib_ui
- *   <=>
- *   <
- *   <=
- *   ==
- *   >=
- *   >
- *   cmpabs
- *   sgn
- *   eql?           r_gmpz_eql              ------------
- *   hash           r_gmpz_hash
- *   and
- *   ior
- *   xor
- *   com            r_gmpz_com              mpz_com
- *   com!           r_gmpz_com_self         mpz_com
- *   popcount       r_gmpz_popcount
- *   scan0          r_gmpz_scan0            mpz_scan0
- *   scan1          r_gmpz_scan1            mpz_scan1
- *   []=            r_gmpz_setbit           mpz_setbit
- *   []             r_gmpz_getbit           mpz_tstbit
- *   even?          r_gmpz_is_even          mpz_even
- *   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
  */
 
 /**********************************************************************
@@ -251,16 +172,38 @@ static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg)        \
   return res;                                                \
 }
 
+#define DEFUN_INT_COND_P(fname,mpz_fname)       \
+static VALUE r_gmpz_##fname(VALUE self)         \
+{                                               \
+  MP_INT *self_val;                             \
+  mpz_get_struct (self, self_val);              \
+  return mpz_fname (self_val) ? Qtrue : Qfalse; \
+}
+
 /**********************************************************************
  *    Initializing, Assigning Integers                                *
  **********************************************************************/
 
 /*
  * call-seq:
- *   GMP::Z.new(arg = 0)
+ *   GMP::Z.new(value = 0)
  *
- * Creates a new GMP::Z integer, with +arg+ as its value, converting where
- * necessary.
+ * Creates a new GMP::Z integer, with _value_ as its value, converting where necessary.
+ * _value_ must be an instance of one of the following classes:
+ *
+ * * GMP::Z
+ * * Fixnum
+ * * String
+ * * Bignum
+ *
+ * @example
+ *   GMP::Z.new(5)        #=> 5
+ *   GMP::Z.new(2**32)    #=> 4_294_967_296
+ *   GMP::Z.new(2**101)   #=> 2_535_301_200_456_458_802_993_406_410_752
+ *   GMP::Z.new("20")     #=> 20
+ *   GMP::Z.new("0x20")   #=> 32
+ *   GMP::Z.new("020")    #=> 16
+ *   GMP::Z.new("0b101")  #=> 5
  */
 VALUE r_gmpzsg_new(int argc, VALUE *argv, VALUE klass)
 {
@@ -293,8 +236,8 @@ VALUE r_gmpz_initialize(int argc, VALUE *argv, VALUE self)
  * call-seq:
  *   a = b
  *
- * Sets the value of +a+ to the value of +b+. +b+ may be one of the following
- * classes:
+ * Sets the value of _a_ to the value of _b_. _b_ must be an instance of one of the
+ * following classes:
  *
  * * GMP::Z
  * * Fixnum
@@ -321,9 +264,9 @@ void mpz_set_value(MP_INT *target, VALUE source)
 
 /*
  * call-seq:
- *   GMP::Z(arg)
+ *   GMP::Z(value)
  *
- * A convenience method for +GMP::Z.new(arg)+.
+ * A convenience method for GMP::Z.new(value).
  */
 VALUE r_gmpmod_z(int argc, VALUE *argv, VALUE module)
 {
@@ -333,9 +276,11 @@ VALUE r_gmpmod_z(int argc, VALUE *argv, VALUE module)
 
 /*
  * call-seq:
- *   int1.swap int2
+ *   a.swap(b)
  *
- * Efficiently swaps the contents of +int1+ with +int2+.
+ * @return nil
+ *
+ * Efficiently swaps the contents of _a_ with _b_. _b_ must be an instance of GMP::Z.
  */
 VALUE r_gmpz_swap(VALUE self, VALUE arg)
 {
@@ -356,16 +301,17 @@ VALUE r_gmpz_swap(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   integer.to_i
+ *   a.to_i
+ *
+ * @todo Implement mpz_fits_slong_p
  *
- * Returns +integer+ as an Fixnum if +integer+ fits in a Fixnum.
+ * Returns _a_ as an Fixnum if _a_ fits into a Fixnum.
  *
- * Otherwise returns the least significant part of +integer+, with the same
- * sign as +integer+.
+ * Otherwise returns the least significant part of _a_, with the same sign as _a_.
  *
- * If +integer+ is too big to fit in a Fixnum, the returned result is probably
- * not very useful. To find out if the value will fit, use the function
- * mpz_fits_slong_p (<b>Unimplemented</b>).
+ * If _a_ is too big to fit in a Fixnum, the returned result is probably not very useful.
+ * To find out if the value will fit, use the function +mpz_fits_slong_p+
+ * (<b>Unimplemented</b>).
  */
 VALUE r_gmpz_to_i(VALUE self)
 {
@@ -384,16 +330,17 @@ VALUE r_gmpz_to_i(VALUE self)
 
 /*
  * call-seq:
- *   integer.to_d
+ *   a.to_d
  *
- * Returns +integer+ as an Float if +integer+ fits in a Float.
+ * @todo Implement mpz_fits_slong_p
  *
- * Otherwise returns the least significant part of +integer+, with the same
- * sign as +integer+.
+ * Returns _a_ as a Float if _a_ fits in a Float.
  *
- * If +integer+ is too big to fit in a Float, the returned result is probably
- * not very useful. To find out if the value will fit, use the function
- * mpz_fits_slong_p (<b>Unimplemented</b>).
+ * Otherwise returns the least significant part of _a_, with the same sign as _a_.
+ *
+ * If _a_ is too big to fit in a Float, the returned result is probably not very useful.
+ * To find out if the value will fit, use the function +mpz_fits_slong_p+
+ * (<b>Unimplemented</b>).
  */
 VALUE r_gmpz_to_d(VALUE self)
 {
@@ -407,20 +354,23 @@ VALUE r_gmpz_to_d(VALUE self)
  * Document-method: to_s
  *
  * call-seq:
- *   integer.to_s(base = 10)
+ *   a.to_s(base = 10)
+ *   a.to_s(:bin)
+ *   a.to_s(:oct)
+ *   a.to_s(:dec)
+ *   a.to_s(:hex)
  *
- * Returns +integer+, as a Ruby string. If +base+ is not provided, then
- * the string will be the decimal representation.
+ * Returns _a_, as a String. If _base_ is not provided, then the decimal
+ * representation will be returned.
  *
  * From the GMP Manual:
  *
- * Convert +integer+ to a string of digits in base +base+. The +base+ argument
- * may vary from 2 to 62 or from -2 to -36.
+ * Convert _a_ to a string of digits in base _base_. The _base_ argument may vary from 2
+ * to 62 or from -2 to -36.
  *
- * For +base+ in the range 2..36, digits and lower-case letters are used; for
- * -2..-36, digits and upper-case letters are used; for 37..62, digits,
- * upper-case letters, and lower-case letters (in that significance order) are
- * used.
+ * For _base_ in the range 2..36, digits and lower-case letters are used; for -2..-36,
+ * digits and upper-case letters are used; for 37..62, digits, upper-case letters, and
+ * lower-case letters (in that significance order) are used.
  */
 VALUE r_gmpz_to_s(int argc, VALUE *argv, VALUE self)
 {
@@ -480,9 +430,9 @@ VALUE r_gmpz_to_s(int argc, VALUE *argv, VALUE self)
 
 /*
  * call-seq:
- *   +(other)
+ *   a + b
  *
- * Adds this GMP::Z to other. Other can be
+ * Adds _a_ to _b_. _b_ must be an instance of one of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -527,10 +477,9 @@ VALUE r_gmpz_add(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   add!(other)
+ *   a.add!(_b_)
  *
- * Adds this GMP::Z to other, and sets this GMP::Z's value to the result. Other
- * can be
+ * Adds _a_ to _b_ in-place, setting _a_ to the sum. _b_ must be an instance of one of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -563,9 +512,9 @@ VALUE r_gmpz_add_self(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   -(other)
+ *   a - b
  *
- * Subtracts other from this GMP::Z. Other can be
+ * Subtracts _b_ from _a_. _b_ must be an instance of one of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -615,10 +564,10 @@ VALUE r_gmpz_sub(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   sub!(other)
+ *   a.sub!(b)
  *
- * Subtracts other from this GMP::Z, and sets this GMP::Z's value to the
- * result. Other can be
+ * Subtracts _b_ from _a_ in-place, setting _a_ to the difference. _b_ must be an
+ * instance of one of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -651,9 +600,9 @@ VALUE r_gmpz_sub_self(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   *(other)
+ *   a * b
  *
- * Multiplies this GMP::Z with other. Other can be
+ * Multiplies _a_ with _b_. _a_ must be an instance of one of
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -696,11 +645,14 @@ VALUE r_gmpz_mul(VALUE self, VALUE arg)
  * call-seq:
  *   a.addmul!(b, c)
  *
- * From the GMP Manual:
- * 
- * Sets +a+ to +a+ plus +b+ times +c+.
+ * @since 0.4.19
+ *
+ * Sets _a_ to _a_ plus _b_ times _c_. _b_ and _c_ must each be an instance of one of
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
  */
-VALUE r_gmpz_addmul_self(VALUE self, VALUE b, VALUE c)
+static VALUE r_gmpz_addmul_self(VALUE self, VALUE b, VALUE c)
 {
   MP_INT *self_val, *b_val, *c_val;
   int free_b_val = 0;
@@ -743,16 +695,68 @@ VALUE r_gmpz_addmul_self(VALUE self, VALUE b, VALUE c)
   return self;
 }
 
+/*
+ * call-seq:
+ *   a.submul!(b, c)
+ *
+ * @since 0.5.23
+ *
+ * Sets _a_ to _a_ minus _b_ times _c_. _b_ and _c_ must each be an instance of one of
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
+ */
+static VALUE r_gmpz_submul_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_submul(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_submul_ui(self_val, b_val, FIX2NUM(c));
+  } else if (BIGNUM_P(c)) {
+    mpz_temp_from_bignum(c_val, c);
+    mpz_submul(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: <<
  *
  * call-seq:
- *   integer << n
+ *   a << n
  *
- * From the GMP Manual:
- * 
- * Returns +integer+ times 2 raised to +n+. This operation can also be defined
- * as a left shift by +n+ bits.
+ * Returns _a_ times 2 raised to _n_. This operation can also be defined as a left shift
+ * by _n_ bits.
  */
 DEFUN_INT_F_UL(shl,mpz_mul_2exp,"shift size")
 
@@ -760,43 +764,35 @@ DEFUN_INT_F_UL(shl,mpz_mul_2exp,"shift size")
  * Document-method: neg
  *
  * call-seq:
- *   integer.neg
- *   -integer
+ *   a.neg
+ *   -a
  *
- * From the GMP Manual:
- * 
- * Returns -+integer+.
+ * Returns -_a_.
  */
 /*
  * Document-method: neg!
  *
  * call-seq:
- *   integer.neg!
+ *   a.neg!
  *
- * From the GMP Manual:
- * 
- * Sets +integer+ to -+integer+.
+ * Sets _a_ to -_a_.
  */
 DEFUN_INT2INT(neg, mpz_neg)
 /*
  * Document-method: abs
  *
  * call-seq:
- *   integer.abs
+ *   a.abs
  *
- * From the GMP Manual:
- * 
- * Returns the absolute value of +integer+.
+ * Returns the absolute value of _a_.
  */
 /*
  * Document-method: abs!
  *
  * call-seq:
- *   integer.abs!
+ *   a.abs!
  *
- * From the GMP Manual:
- * 
- * Sets +integer+ to its absolute value.
+ * Sets _a_ to its absolute value.
  */
 DEFUN_INT2INT(abs, mpz_abs)
 
@@ -809,10 +805,9 @@ DEFUN_INT2INT(abs, mpz_abs)
  * call-seq:
  *   a / b
  *
- * Divides _a_ by _b_. Combines the different GMP division functions to
- * provide what one is hopefully looking for. The result will either be
- * an instance of GMP::Q or GMP::F, depending on _b_. _b_ can be an
- * instance of any of the following:
+ * Divides _a_ by _b_. Combines the different GMP division functions to provide what one
+ * is hopefully looking for. The result will either be an instance of GMP::Q or GMP::F,
+ * depending on _b_. _b_ must be an instance of one of the following:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -881,15 +876,12 @@ VALUE r_gmpz_div(VALUE self, VALUE arg)
  * Document-method: tdiv
  *
  * call-seq:
- *   n.tdiv d
- *
- * From the GMP Manual:
+ *   n.tdiv(d)
  * 
- * Divides +n+ by +d+, forming a quotient +q+. tdiv rounds +q+ towards zero.
- * The +t+ stands for "truncate".
+ * Divides _n_ by _d_, forming a quotient _q_. tdiv rounds _q_ towards zero. The _t_
+ * stands for "truncate".
  *
- * +q+ will satisfy <tt>n=q*d+r</tt>, and +r+ will satisfy
- * <tt>0<=abs(r)<abs(d)</tt>.
+ * _q_ will satisfy <i>n=q*d+r</i>, and _r_ will satisfy <i>0 <= abs( r ) < abs( d )</i>.
  *
  * This function calculates only the quotient.
  */
@@ -898,34 +890,45 @@ DEFUN_INT_DIV(tdiv, mpz_tdiv_q)
  * Document-method: tmod
  *
  * call-seq:
- *   n.tmod d
- *
- * From the GMP Manual:
+ *   n.tmod(d)
  * 
- * Divides +n+ by +d+, forming a remainder +r+. +r+ will have the same sign as
- * +n+. The +t+ stands for �truncate�. 
+ * Divides _n_ by _d_, forming a remainder _r_. _r_ will have the same sign as _n_. The
+ * _t_ stands for "truncate". 
  *
- * +r+ will satisfy <tt>n=q*d+r</tt>, and +r+ will satisfy
- * <tt>0<=abs(r)<abs(d)</tt>.
+ * _r_ will satisfy <i>n=q*d+r</i>, and _r_ will satisfy <i>0 <= abs( r ) < abs( d )</i>.
  *
  * This function calculates only the remainder.
  *
- * The remainder can be negative, so the return value is the absolute value of
- * the remainder.
+ * The remainder can be negative, so the return value is the absolute value of the
+ * remainder.
  */
 DEFUN_INT_DIV(tmod, mpz_tdiv_r)
+/*
+ * Document-method: tshr
+ *
+ * call-seq:
+ *   n.tshr(d)
+ * 
+ * Divides _n_ by 2^<i>d</i>, forming a quotient _q_. tshr rounds _q_ towards zero. The
+ * _t_ stands for "truncate". 
+ *
+ * _q_ will satisfy <i>n=q*d+r</i>, and _r_ will satisfy <i>0 <= abs( r ) < abs( d )</i>.
+ *
+ * This function calculates only the quotient.
+ */
+DEFUN_INT_F_UL(tshr,mpz_tdiv_q_2exp,"shift size")
+DEFUN_INT_F_UL(tshrm,mpz_tdiv_r_2exp,"mark size")
+
 /*
  * Document-method: fdiv
  *
  * call-seq:
- *   n.fdiv d
+ *   n.fdiv(d)
  *
- * From the GMP Manual:
- * 
- * Divide n by d, forming a quotient q. fdiv rounds q down towards -infinity.
- * The f stands for �floor�.
+ * Divide _n_ by _d_, forming a quotient _q_. fdiv rounds _q_ down towards -infinity.
+ * The f stands for "floor".
  *
- * q will satisfy n=q*d+r.
+ * _q_ will satisfy <i>n=q*d+r</i>.
  *
  * This function calculates only the quotient.
  */
@@ -934,33 +937,32 @@ DEFUN_INT_DIV(fdiv, mpz_fdiv_q)
  * Document-method: fmod
  *
  * call-seq:
- *   n.fmod d
+ *   n.fmod(d)
  *
- * From the GMP Manual:
- * 
- * Divides n by d, forming a remainder r. r will have the same sign as d. The f
- * stands for �floor�. 
+ * Divides _n_ by _d_, forming a remainder _r_. _r_ will have the same sign as _d_. The
+ * _f_ stands for "floor". 
  *
- * r will satisfy n=q*d+r, and r will satisfy 0<=abs(r)<abs(d).
+ * _r_ will satisfy <i>n=q*d+r</i>, and _r_ will satisfy <i>0 <= abs( r ) < abs( d )</i>.
  *
  * This function calculates only the remainder.
  *
- * The remainder can be negative, so the return value is the absolute value of
- * the remainder.
+ * The remainder can be negative, so the return value is the absolute value of the
+ * remainder.
  */
 DEFUN_INT_DIV(fmod, mpz_fdiv_r)
+DEFUN_INT_F_UL(fshr,mpz_fdiv_q_2exp,"shift size")
+DEFUN_INT_F_UL(fshrm,mpz_fdiv_r_2exp,"mark size")
+
 /*
  * Document-method: cdiv
  *
  * call-seq:
- *   n.cdiv d
+ *   n.cdiv(d)
  *
- * From the GMP Manual:
- * 
- * Divide +n+ by +d+, forming a quotient +q+. +cdiv+ rounds +q+ up towards
- * <tt>+infinity</tt>. The c stands for �ceil�.
+ * Divide _n_ by _d_, forming a quotient _q_. cdiv rounds _q_ up towards
+ * _+infinity_. The c stands for "ceil".
  *
- * +q+ will satisfy <tt>n=q*d+r</tt>.
+ * _q_ will satisfy <i>n=q*d+r</i>.
  *
  * This function calculates only the quotient.
  */
@@ -969,15 +971,12 @@ DEFUN_INT_DIV(cdiv, mpz_cdiv_q)
  * Document-method: cmod
  *
  * call-seq:
- *   n.cmod d
+ *   n.cmod(d)
  *
- * From the GMP Manual:
- * 
- * Divides +n+ by +d+, forming a remainder +r+. +r+ will have the opposite sign
- * as +d+. The c stands for �ceil�.
+ * Divides _n_ by _d_, forming a remainder _r_. _r_ will have the opposite sign of _d_.
+ * The c stands for "ceil".
  *
- * +r+ will satisfy <tt>n=q*d+r</tt>, and +r+ will satisfy
- * <tt>0<=abs(r)<abs(d)</tt>.
+ * _r_ will satisfy <i>n=q*d+r</i>, and _r_ will satisfy <i>0 <= abs( r ) < abs( d )</i>.
  *
  * This function calculates only the remainder.
  */
@@ -987,6 +986,8 @@ DEFUN_INT_DIV(cmod, mpz_cdiv_r)
  * call-seq:
  *   a % b
  *
+ * @since 0.2.10
+ *
  * Returns _a_ mod _b_. _b_ can be an instance any of the following:
  * * GMP::Z
  * * Fixnum
@@ -1016,6 +1017,47 @@ VALUE r_gmpz_mod(VALUE self, VALUE arg)
   return res;
 }
 
+/*
+ * call-seq:
+ *   a.divisible?(b)
+ *
+ * @since 0.5.23
+ *
+ * Returns true if _a_ is divisible by _b_. _b_ can be an instance any of the following:
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
+ */
+static VALUE r_gmpz_divisible(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val;
+  int res;
+  mpz_get_struct (self, self_val);
+  
+  if (FIXNUM_P (arg) && FIX2NUM (arg) > 0) {
+    mpz_temp_alloc(arg_val);
+    mpz_init_set_ui(arg_val, FIX2NUM(arg));
+    res = mpz_divisible_ui_p (self_val, FIX2NUM (arg));
+    mpz_temp_free(arg_val);
+  } else if (FIXNUM_P (arg)) {
+    mpz_temp_alloc(arg_val);
+    mpz_make_struct_init (arg, arg_val);
+    mpz_init_set_si(arg_val, FIX2NUM(arg));
+    res = mpz_divisible_p (self_val, arg_val);
+    mpz_temp_free(arg_val);
+  } else if (BIGNUM_P (arg)) {
+    mpz_temp_from_bignum(arg_val, arg);
+    res = mpz_divisible_p (self_val, arg_val);
+    mpz_temp_free(arg_val);
+  } else if (GMPZ_P (arg)) {
+    mpz_get_struct(arg, arg_val);
+    res = mpz_divisible_p (self_val, arg_val);
+  } else {
+    typeerror_as (ZXB, "argument");
+  }
+  return (res != 0) ? Qtrue : Qfalse;
+}
+
 
 /**********************************************************************
  *    Integer Exponentiation                                          *
@@ -1025,25 +1067,46 @@ VALUE r_gmpz_mod(VALUE self, VALUE arg)
  * Document-method: **
  *
  * call-seq:
- *   integer ** exp
+ *   a ** b
  *
- * From the GMP Manual:
- * 
- * Returns +integer+ raised to +exp+. The case 0^0 yields 1.
+ * Returns _a_ raised to _b_. The case 0^0 yields 1.
  */
 DEFUN_INT_F_UL(pow,mpz_pow_ui,"exponent")
 
 /*
+ * Document-method: GMP::Z.pow
+ *
  * call-seq:
- *   integer.powmod(exp, mod)
+ *   GMP::Z.pow(a, b)
  *
- * From the GMP Manual:
- * 
- * Returns +integer+ raised to +exp+ modulo +mod+.
+ * Returns _a_ raised to _b_. The case 0^0 yields 1.
+ */
+VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp)
+{
+  MP_INT *res_val;
+  VALUE res;
+
+  if (FIXNUM_P(base) && FIXNUM_P(exp))
+  {
+    if (FIX2NUM(base) < 0)
+      rb_raise (rb_eRangeError, "base must not be negative");
+    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, FIX2NUM(base), FIX2NUM(exp));
+    return res;
+  }
+  return r_gmpz_pow (r_gmpzsg_new(1, &base, klass), exp);
+}
+
+/*
+ * call-seq:
+ *   a.powmod(b, c)
  *
- * Negative +exp+ is supported if an inverse <tt>integer^-1</tt> mod
- * <tt>mod</tt> exists. If an inverse doesn't exist then a divide by zero is
- * raised.
+ * Returns _a_ raised to _b_ modulo _c_.
+ *
+ * Negative _b_ is supported if an inverse <i>a^-1</i> mod _c_ exists. If an inverse
+ * doesn't exist then a divide by zero is raised.
  */
 VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod)
 {
@@ -1113,11 +1176,9 @@ VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod)
  * Document-method: root
  *
  * call-seq:
- *   GMP::Z.root(m, n)
+ *   a.root(b)
  *
- * From the GMP Manual:
- * 
- * Returns the truncated integer part of the +n+th root of +m+.
+ * Returns the truncated integer part of the <i>b</i>th root of _a_.
  */
 DEFUN_INT_F_UL(root,mpz_root,"root number")
 
@@ -1125,35 +1186,26 @@ DEFUN_INT_F_UL(root,mpz_root,"root number")
  * Document-method: sqrt
  *
  * call-seq:
- *   integer.sqrt
+ *   a.sqrt
  *
- * From the GMP Manual:
- * 
- * Returns the truncated integer part of the square root of +integer+.
+ * Returns the truncated integer part of the square root of _a_.
  */
 /*
  * Document-method: sqrt!
  *
  * call-seq:
- *   integer.sqrt!
+ *   a.sqrt!
  *
- * From the GMP Manual:
- * 
- * Sets +integer+ to the truncated integer part of its square root.
+ * Sets _a_ to the truncated integer part of its square root.
  */
 DEFUN_INT2INT(sqrt, mpz_sqrt)
 
 /*
- * Document-method: sqrtrem
- *
  * call-seq:
- *   integer.sqrtrem #=> sqrt, rem
+ *   a.sqrtrem #=> s, r
  *
- * From the GMP Manual:
- * 
- * Returns the truncated integer part of the square root of +integer+ as
- * +sqrt+ and the remainder <tt>integer - sqrt * sqrt</tt> as +rem+, which will
- * be zero if +integer+ is a perfect square.
+ * Returns the truncated integer part of the square root of _a_ as _s_ and the remainder
+ * <i>a - s * s</i> as _r_, which will be zero if _a_ is a perfect square.
  */
 static VALUE r_gmpz_sqrtrem(VALUE self)
 {
@@ -1171,29 +1223,23 @@ static VALUE r_gmpz_sqrtrem(VALUE self)
  * Document-method: power?
  *
  * call-seq:
- *   integer.power?
+ *   p.power?
  *
- * From the GMP Manual:
- * 
- * Returns true if integer is a perfect power, i.e., if there exist integers a
- * and b, with b>1, such that integer equals a raised to the power b.
+ * Returns true if _p_ is a perfect power, i.e., if there exist integers _a_ and _b_,
+ * with <i>b > 1</i>, such that _p_ equals _a_ raised to the power _b_.
  *
- * Under this definition both 0 and 1 are considered to be perfect powers.
- * Negative values of integers are accepted, but of course can only be odd
- * perfect powers.
+ * Under this definition both 0 and 1 are considered to be perfect powers. Negative
+ * values of integers are accepted, but of course can only be odd perfect powers.
  */
 DEFUN_INT_COND_P(is_power,mpz_perfect_power_p)
 /*
  * Document-method: square?
  *
  * call-seq:
- *   integer.square?
+ *   p.square?
  *
- * From the GMP Manual:
- * 
- * Returns true if integer is a perfect square, i.e., if the square root of
- * integer is an integer. Under this definition both 0 and 1 are considered to
- * be perfect squares.
+ * Returns true if _p_ is a perfect square, i.e., if the square root of _p_ is an
+ * integer. Under this definition both 0 and 1 are considered to be perfect squares.
  */
 DEFUN_INT_COND_P(is_square,mpz_perfect_square_p)
 
@@ -1203,21 +1249,22 @@ DEFUN_INT_COND_P(is_square,mpz_perfect_square_p)
  **********************************************************************/
 
 /*
- * call-seq: probab_prime?(reps = 5)
+ * call-seq:
+ *   n.probab_prime?(reps = 5)
  *
- * Determine whether +n+ is prime. Returns 2 if +n+ is definitely prime,
- * returns 1 if +n+ is probably prime (without being certain), or returns 0 if
- * +n+ is definitely composite.
+ * Determine whether _n_ is prime. Returns 2 if _n_ is definitely prime, returns 1 if _n_
+ * is probably prime (without being certain), or returns 0 if _n_ is definitely
+ * composite.
  *
- * This function does some trial divisions, then some Miller-Rabin
- * probabilistic primality tests. +reps+ controls how many such tests are done,
- * 5 to 10 is a reasonable number, more will reduce the chances of a composite
- * being returned as "probably prime".
+ * This function does some trial divisions, then some Miller-Rabin probabilistic
+ * primality tests. +reps+ controls how many such tests are done, 5 to 10 is a reasonable
+ * number, more will reduce the chances of a composite being returned as "probably
+ * prime".
  *
- * Miller-Rabin and similar tests can be more properly called compositeness
- * tests. Numbers which fail are known to be composite but those which pass
- * might be prime or might be composite. Only a few composites pass, hence
- * those which pass are considered probably prime.
+ * Miller-Rabin and similar tests can be more properly called compositeness tests.
+ * Numbers which fail are known to be composite but those which pass might be prime or
+ * might be composite. Only a few composites pass, hence those which pass are considered
+ * probably prime.
  */
 VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self)
 {
@@ -1241,34 +1288,37 @@ VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self)
  * Document-method: nextprime
  *
  * call-seq:
- *   integer.nextprime
- *   integer.next_prime
+ *   n.nextprime
+ *   n.next_prime
  *
- * From the GMP Manual:
- * 
- * Returns the next prime greater than +integer+.
+ * Returns the next prime greater than _n_.
  *
- * This function uses a probabilistic algorithm to identify primes. For
- * practical purposes it's adequate, the chance of a composite passing will be
- * extremely small.
+ * This function uses a probabilistic algorithm to identify primes. For practical
+ * purposes it's adequate, the chance of a composite passing will be extremely small.
  */
 /*
  * Document-method: nextprime!
  *
  * call-seq:
- *   integer.nextprime!
- *   integer.next_prime!
+ *   n.nextprime!
+ *   n.next_prime!
  *
- * From the GMP Manual:
- * 
- * Sets +integer+ to the next prime greater than +integer+.
+ * Sets _n_ to the next prime greater than _n_.
  *
- * This function uses a probabilistic algorithm to identify primes. For
- * practical purposes it's adequate, the chance of a composite passing will be
- * extremely small.
+ * This function uses a probabilistic algorithm to identify primes. For practical
+ * purposes it's adequate, the chance of a composite passing will be extremely small.
  */
 DEFUN_INT2INT(nextprime, mpz_nextprime)
 
+/*
+ * call-seq:
+ *   a.gcd(b)
+ *
+ * @since 0.2.11
+ *
+ * Returns the greatest common divisor of a and b. The result is always positive even if
+ * one or both of _a_ or _b_ are negative.
+ */
 VALUE r_gmpz_gcd(VALUE self, VALUE arg)
 {
   MP_INT *self_val, *arg_val, *res_val;
@@ -1293,6 +1343,66 @@ VALUE r_gmpz_gcd(VALUE self, VALUE arg)
   return res;
 }
 
+/*
+ * call-seq:
+ *   a.gcdext(b) #=> g, s, t
+ *
+ * @since 0.5.23
+ *
+ * Returns the greatest common divisor of _a_ and _b_, in addition to _s_ and _t_, the
+ * coefficients satisfying <i>a*s + b*t = g</i>. _g_ is always positive, even if one or
+ * both of _a_ and _b_ are negative. _s_ and _t_ are chosen such that
+ * <i>abs(s) <= abs(b)</i> and <i>abs(t) <= abs(a)</i>.
+ */
+VALUE r_gmpz_gcdext(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val, *res_val, *s_val, *t_val;
+  VALUE res, s, t, ary;
+  int free_arg_val = 0;
+
+  mpz_get_struct (self,self_val);
+
+  if (GMPZ_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_make_struct_init (s, s_val);
+    mpz_make_struct_init (t, t_val);
+    mpz_get_struct (arg, arg_val);
+    mpz_gcdext (res_val, s_val, t_val, self_val, arg_val);
+  } else if (FIXNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_make_struct_init (s, s_val);
+    mpz_make_struct_init (t, t_val);
+    mpz_temp_alloc(arg_val);
+    mpz_init_set_ui(arg_val, FIX2NUM(arg));
+    free_arg_val = 1;
+    mpz_gcdext (res_val, s_val, t_val, self_val, arg_val);
+  } else if (BIGNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_make_struct_init (s, s_val);
+    mpz_make_struct_init (t, t_val);
+    mpz_set_bignum (res_val, arg);
+    mpz_gcdext (res_val, s_val, t_val, res_val, self_val);
+  } else {
+    typeerror (ZXB);
+  }
+  
+  if (free_arg_val)
+    mpz_temp_free(arg_val);
+  
+  ary = rb_ary_new3(3, res, s, t);
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   a.invert(b)
+ *
+ * @since 0.2.11
+ *
+ * Returns the inverse of _a_ modulo _b_. If the inverse exists, the return value is
+ * non-zero and the result will be non-negative and less than _b_. If an inverse doesn't
+ * exist, the result is undefined.
+ */
 VALUE r_gmpz_invert(VALUE self, VALUE arg)
 {
   MP_INT *self_val, *arg_val, *res_val;
@@ -1320,15 +1430,11 @@ VALUE r_gmpz_invert(VALUE self, VALUE arg)
 }
 
 /*
- * Document-method: jacobi
- *
  * call-seq:
  *   a.jacobi(b)
  *
- * From the GMP Manual:
- * 
- * Calculate the Jacobi symbol <tt>(a/b)</tt>. This is defined only for +b+
- * odd and positive.
+ * Calculate the Jacobi symbol <i>(a/b)</i>. This is defined only for _b_ odd and
+ * positive.
  */
 VALUE r_gmpz_jacobi(VALUE self, VALUE b)
 {
@@ -1345,15 +1451,11 @@ VALUE r_gmpz_jacobi(VALUE self, VALUE b)
 }
 
 /*
- * Document-method: GMP::Z.jacobi
- *
  * call-seq:
  *   GMP::Z.jacobi(a, b)
- *
- * From the GMP Manual:
  * 
- * Calculate the Jacobi symbol <tt>(a/b)</tt>. This is defined only for +b+
- * odd and positive.
+ * Calculate the Jacobi symbol <i>(a/b)</i>. This is defined only for _b_ odd and
+ * positive.
  */
 VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b)
 {
@@ -1412,15 +1514,11 @@ VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b)
 }
 
 /*
- * Document-method: legendre
- *
  * call-seq:
  *   a.legendre(p)
  *
- * From the GMP Manual:
- * 
- * Calculate the Legendre symbol <tt>(a/p)</tt>. This is defined only for +p+
- * an odd positive prime, and for such +p+ it's identical to the Jacobi symbol. 
+ * Calculate the Legendre symbol <i>(a/p)</i>. This is defined only for _p_ an odd
+ * positive prime, and for such _p_ it's identical to the Jacobi symbol. 
  */
 VALUE r_gmpz_legendre(VALUE self, VALUE p)
 {
@@ -1439,15 +1537,11 @@ VALUE r_gmpz_legendre(VALUE self, VALUE p)
 }
 
 /*
- * Document-method: remove
- *
  * call-seq:
- *   integer.remove(factor)
+ *   n.remove(f) #=> r, t
  *
- * From the GMP Manual:
- * 
- * Remove all occurrences of the factor +factor+ from +integer+. The return
- * value is how many such occurrences were removed.
+ * Remove all occurrences of the factor _f_ from _n_, returning the result as _r_. _t_,
+ * how many such occurrences were removed, is also returned.
  */
 VALUE r_gmpz_remove(VALUE self, VALUE arg)
 {
@@ -1496,17 +1590,14 @@ VALUE r_gmpz_remove(VALUE self, VALUE arg)
  * call-seq:
  *   GMP::Z.fac(n)
  *
- * From the GMP Manual:
- * 
- * Returns <tt>n!</tt>, the factorial of +n+.
+ * Returns <i>n!</i>, the factorial of _n_.
  *
  * Examples:
- *
- * GMP::Z.fac(0)  #=>  1
- * GMP::Z.fac(1)  #=>  1
- * GMP::Z.fac(2)  #=>  2
- * GMP::Z.fac(3)  #=>  6
- * GMP::Z.fac(4)  #=> 24
+ * * GMP::Z.fac(0)  #=>  1
+ * * GMP::Z.fac(1)  #=>  1
+ * * GMP::Z.fac(2)  #=>  2
+ * * GMP::Z.fac(3)  #=>  6
+ * * GMP::Z.fac(4)  #=> 24
  */
 DEFUN_INT_SINGLETON_UI(fac, mpz_fac_ui)
 /*
@@ -1515,19 +1606,16 @@ DEFUN_INT_SINGLETON_UI(fac, mpz_fac_ui)
  * call-seq:
  *   GMP::Z.fib(n)
  *
- * From the GMP Manual:
- * 
- * Returns <tt>F[n]</tt>, the +n+th Fibonacci number.
+ * Returns <i>F[n]</i>, the <i>n</i>th Fibonacci number.
  *
  * Examples:
- *
- * GMP::Z.fib(1)  #=>  1
- * GMP::Z.fib(2)  #=>  1
- * GMP::Z.fib(3)  #=>  2
- * GMP::Z.fac(4)  #=>  3
- * GMP::Z.fac(5)  #=>  5
- * GMP::Z.fac(6)  #=>  8
- * GMP::Z.fac(7)  #=> 13
+ * * GMP::Z.fib(1)  #=>  1
+ * * GMP::Z.fib(2)  #=>  1
+ * * GMP::Z.fib(3)  #=>  2
+ * * GMP::Z.fac(4)  #=>  3
+ * * GMP::Z.fac(5)  #=>  5
+ * * GMP::Z.fac(6)  #=>  8
+ * * GMP::Z.fac(7)  #=> 13
  */
 DEFUN_INT_SINGLETON_UI(fib, mpz_fib_ui)
 
@@ -1536,6 +1624,12 @@ DEFUN_INT_SINGLETON_UI(fib, mpz_fib_ui)
  *    Integer Comparisons                                             *
  **********************************************************************/
 
+/*
+ * call-seq:
+ *   a == b
+ * 
+ * Returns true if _a_ is equal to _b_, and false otherwise.
+ */
 VALUE r_gmpz_eq(VALUE self, VALUE arg)
 {
   MP_INT *self_val, *arg_val_z;
@@ -1597,6 +1691,16 @@ int mpz_cmp_value(MP_INT *OP, VALUE arg)
   }
 }
 
+/*
+ * call-seq:
+ *   a <=> b
+ * 
+ * Returns negative if _a_ is less than _b_.
+ *
+ * Returns 0 if _a_ is equal to _b_.
+ *
+ * Returns positive if _a_ is greater than _b_.
+ */
 VALUE r_gmpz_cmp(VALUE self, VALUE arg)
 {
   MP_INT *self_val;
@@ -1615,39 +1719,49 @@ VALUE r_gmpz_cmp(VALUE self, VALUE arg)
  * Document-method: <
  *
  * call-seq:
- *   int1 < int2
+ *   a < b
  * 
- * Returns whether +int1+ is strictly less than +int2+.
+ * Returns whether _a_ is strictly less than _b_.
  */
 DEFUN_INT_CMP(lt,<)
 /*
  * Document-method: <=
  *
  * call-seq:
- *   int1 <= int2
+ *   a <= b
  * 
- * Returns whether +int1+ is less than or equal to +int2+.
+ * Returns whether _a_ is less than or equal to _b_.
  */
 DEFUN_INT_CMP(le,<=)
 /*
  * Document-method: >
  *
  * call-seq:
- *   int1 > int2
+ *   a > b
  * 
- * Returns whether +int1+ is strictly greater than +int2+.
+ * Returns whether _a_ is strictly greater than _b_.
  */
 DEFUN_INT_CMP(gt,>)
 /*
  * Document-method: >=
  *
  * call-seq:
- *   int1 >= int2
+ *   a >= b
  *
- * Returns whether +int1+ is greater than or equal to +int2+.
+ * Returns whether _a_ is greater than or equal to _b_.
  */
 DEFUN_INT_CMP(ge,>=)
 
+/*
+ * call-seq:
+ *   a.cmpabs(b)
+ * 
+ * Returns negative if abs(_a_) is less than abs(_b_).
+ *
+ * Returns 0 if abs(_a_) is equal to abs(_b_).
+ *
+ * Returns positive if abs(_a_) is greater than abs(_b_).
+ */
 VALUE r_gmpz_cmpabs(VALUE self, VALUE arg)
 {
   MP_INT *arg_val_z, *self_val;
@@ -1686,11 +1800,9 @@ VALUE r_gmpz_cmpabs(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   integer.sgn
+ *   a.sgn
  *
- * From the GMP Manual:
- * 
- * Returns +1 if +integer+ > 0, 0 if +integer+ == 0, and -1 if +integer+ < 0.
+ * Returns +1 if _a_ > 0, 0 if _a_ == 0, and -1 if _a_ < 0.
  */
 VALUE r_gmpz_sgn(VALUE self)
 {
@@ -1699,10 +1811,15 @@ VALUE r_gmpz_sgn(VALUE self)
   return INT2FIX(mpz_sgn(self_val));
 }
 
-
 /*
- * eql? and hash are defined so that GMP::Z objects can be used as keys in
- * hashes.
+ * call-seq:
+ *   a.eql?(b)
+ *
+ * @since 0.4.7
+ *
+ * Returns true if _a_ is equal to _b_. _a_ and _b_ must then be equal in cardinality,
+ * and both be instances of GMP::Z. Otherwise, returns false. a.eql?(b) if and only if
+ * a.hash == b.hash.
  */
 VALUE r_gmpz_eql(VALUE self, VALUE arg)
 {
@@ -1718,6 +1835,16 @@ VALUE r_gmpz_eql(VALUE self, VALUE arg)
   }
 }
 
+/*
+ * call-seq:
+ *   a.hash
+ *
+ * @since 0.4.7
+ *
+ * Returns the computed hash value of _a_. This method first converts _a_ into a String
+ * (base 10), then calls String#hash on the result, returning the hash value. a.eql?(b)
+ * if and only if a.hash == b.hash.
+ */
 VALUE r_gmpz_hash(VALUE self)
 {
   ID to_s_sym = rb_intern("to_s");
@@ -1734,33 +1861,36 @@ VALUE r_gmpz_hash(VALUE self)
  * Document-method: &
  *
  * call-seq:
- *   integer & other
+ *   a & b
  *
- * From the GMP Manual:
- * 
- * Returns +integer+ bitwise-and +other+.
+ * Returns _a_ bitwise-and _b_. _b_ must be an instance of one of the following:
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
  */
 DEFUN_INT_LOGIC(and, mpz_and)
 /*
  * Document-method: |
  *
  * call-seq:
- *   integer | other
+ *   a | b
  *
- * From the GMP Manual:
- * 
- * Returns +integer+ bitwise inclusive-or +other+.
+ * Returns _a_ bitwise inclusive-or _b_. _b_ must be an instance of one of the following:
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
  */
 DEFUN_INT_LOGIC(or, mpz_ior)
 /*
  * Document-method: ^
  *
  * call-seq:
- *   integer ^ other
+ *   a ^ b
  *
- * From the GMP Manual:
- * 
- * Returns +integer+ bitwise exclusive-or +other+.
+ * Returns _a_ bitwise exclusive-or _b_. _b_ must be an instance of one of the following:
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
  */
 DEFUN_INT_LOGIC(xor, mpz_xor)
 
@@ -1768,21 +1898,17 @@ DEFUN_INT_LOGIC(xor, mpz_xor)
  * Document-method: com
  *
  * call-seq:
- *   integer.com
+ *   a.com
  *
- * From the GMP Manual:
- * 
- * Returns the one's complement of +integer+.
+ * Returns the one's complement of _a_.
  */
 /*
  * Document-method: com!
  *
  * call-seq:
- *   integer.com!
+ *   a.com!
  *
- * From the GMP Manual:
- * 
- * Sets +integer+ to its one's complement.
+ * Sets _a_ to its one's complement.
  */
 DEFUN_INT2INT(com, mpz_com)
 
@@ -1790,14 +1916,11 @@ DEFUN_INT2INT(com, mpz_com)
  * Document-method: popcount
  *
  * call-seq:
- *   integer.popcount
+ *   a.popcount
  *
- * From the GMP Manual:
- * 
- * If <tt>integer>=0</tt>, return the population count of <tt>integer</tt>,
- * which is the number of 1 bits in the binary representation. If
- * <tt>op<0</tt>, the number of 1s is infinite, and the return value is
- * INT2FIX(ULONG_MAX), the largest possible unsigned long.
+ * If _a_ >= 0, return the population count of _a_, which is the number of 1 bits in the
+ * binary representation. If _a_ < 0, the number of 1s is infinite, and the return value
+ * is INT2FIX(ULONG_MAX), the largest possible unsigned long.
  */
 VALUE r_gmpz_popcount(VALUE self)
 {
@@ -1808,18 +1931,16 @@ VALUE r_gmpz_popcount(VALUE self)
 
 /*
  * call-seq:
- *   integer.scan0(starting_bit)
+ *   a.scan0(starting_bit)
  *
- * From the GMP Manual:
- * 
- * Scan integer, starting from bit starting_bit, towards more significant bits,
- * until the first 0 bit is found. Return the index of the found bit.
+ * Scan _a_, starting from bit _starting_bit_, towards more significant bits, until the
+ * first 0 bit is found. Return the index of the found bit.
  *
- * If the bit at starting_bit is already what's sought, then starting_bit is
+ * If the bit at _starting_bit_ is already what's sought, then _starting_bit_ is
  * returned.
  * 
- * If there's no bit found, then INT2FIX(ULONG_MAX) is returned. This will
- * happen in scan0 past the end of a negative number.
+ * If there's no bit found, then INT2FIX(ULONG_MAX) is returned. This will happen in
+ * scan0 past the end of a negative number.
  */
 VALUE r_gmpz_scan0(VALUE self, VALUE bitnr)
 {
@@ -1836,18 +1957,16 @@ VALUE r_gmpz_scan0(VALUE self, VALUE bitnr)
 
 /*
  * call-seq:
- *   integer.scan1(starting_bit)
+ *   a.scan1(starting_bit)
  *
- * From the GMP Manual:
+ * Scan _a_, starting from bit _starting_bit_, towards more significant bits, until the
+ * first 1 bit is found. Return the index of the found bit.
  * 
- * Scan integer, starting from bit starting_bit, towards more significant bits,
- * until the first 1 bit is found. Return the index of the found bit.
- *
- * If the bit at starting_bit is already what's sought, then starting_bit is
+ * If the bit at _starting_bit_ is already what's sought, then _starting_bit_ is
  * returned.
  *
- * If there's no bit found, then INT2FIX(ULONG_MAX) is returned. This will
- * happen in mpz_scan1 past the end of a nonnegative number.
+ * If there's no bit found, then INT2FIX(ULONG_MAX) is returned. This will happen in
+ * scan1 past the end of a nonnegative number.
  */
 VALUE r_gmpz_scan1(VALUE self, VALUE bitnr)
 {
@@ -1867,9 +1986,9 @@ VALUE r_gmpz_scan1(VALUE self, VALUE bitnr)
 
 /*
  * call-seq:
- *   integer[index] = x &rarr; nil
+ *   a[index] = x
  *
- * Sets the bit at index to x.
+ * Sets the bit at _index_ to _x_.
  */
 VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to)
 {
@@ -1896,9 +2015,9 @@ VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to)
 
 /*
  * call-seq:
- *   integer[index] &rarr; boolean
+ *   a[index] #=> boolean
  *
- * Gets the bit at index, returned as either true or false.
+ * Gets the bit at _index_, returned as either true or false.
  */
 VALUE r_gmpz_getbit(VALUE self, VALUE bitnr)
 {
@@ -1922,25 +2041,33 @@ VALUE r_gmpz_getbit(VALUE self, VALUE bitnr)
  * Document-method: even?
  *
  * call-seq:
- *   integer.even?
+ *   a.even?
  *
- * From the GMP Manual:
- * 
- * Determines whether integer is even. Returns true or false.
+ * Determines whether _a_ is even. Returns true or false.
  */
 DEFUN_INT_COND_P(is_even,mpz_even_p)
 /*
  * Document-method: odd?
  *
  * call-seq:
- *   integer.odd?
+ *   a.odd?
  *
- * From the GMP Manual:
- * 
- * Determines whether integer is odd. Returns true or false.
+ * Determines whether _a_ is odd. Returns true or false.
  */
 DEFUN_INT_COND_P(is_odd,mpz_odd_p)
 
+/*
+ * call-seq:
+ *   a.sizeinbase
+ *   a.size_in_base
+ *
+ * @since 0.2.11
+ *
+ * Return the size of _a_ measured in number of digits in the given base. base can vary
+ * from 2 to 62. The sign of _a_ is ignored, just the absolute value is used. The result
+ * will be either exact or 1 too big. If base is a power of 2, the result is always
+ * exact. If _a_ is zero the return value is always 1.
+ */
 VALUE r_gmpz_sizeinbase(VALUE self, VALUE base)
 {
   MP_INT *self_val;
@@ -1950,6 +2077,15 @@ VALUE r_gmpz_sizeinbase(VALUE self, VALUE base)
   return INT2FIX (mpz_sizeinbase (self_val, base_val));
 }
 
+/*
+ * call-seq:
+ *   a.size_in_bin
+ *
+ * @since 0.2.11
+ *
+ * Return the size of _a_ measured in number of digits in binary. The sign of _a_ is
+ * ignored, just the absolute value is used. If _a_ is zero the return value is 1.
+ */
 VALUE r_gmpz_size_in_bin(VALUE self)
 {
   MP_INT *self_val;
@@ -1963,15 +2099,13 @@ VALUE r_gmpz_size_in_bin(VALUE self)
  **********************************************************************/
 
 /*
- * Document-method: size
- *
  * call-seq:
- *   integer.size
+ *   a.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. 
+ * @since 0.4.19
+ *
+ * Return the size of _a_ measured in number of limbs. If _a_ is zero, the returned
+ * value will be zero. 
  */
 VALUE r_gmpz_size(VALUE self)
 {
@@ -1985,28 +2119,10 @@ VALUE r_gmpz_size(VALUE self)
  *    _unsorted_                                                      *
  **********************************************************************/
 
-DEFUN_INT_F_UL(fshr,mpz_fdiv_q_2exp,"shift size")
-DEFUN_INT_F_UL(tshr,mpz_tdiv_q_2exp,"shift size")
-DEFUN_INT_F_UL(fshrm,mpz_fdiv_r_2exp,"mark size")
-DEFUN_INT_F_UL(tshrm,mpz_tdiv_r_2exp,"mark size")
-
-VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp)
-{
-  MP_INT *res_val;
-  VALUE res;
 
-  if (FIXNUM_P(base) && FIXNUM_P(exp))
-  {
-    if (FIX2NUM(base) < 0)
-      rb_raise (rb_eRangeError, "base must not be negative");
-    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, FIX2NUM(base), FIX2NUM(exp));
-    return res;
-  }
-  return r_gmpz_pow (r_gmpzsg_new(1, &base, klass), exp);
-}
+/**********************************************************************
+ *    Init function                                                   *
+ **********************************************************************/
 
 void init_gmpz()
 {
@@ -2017,8 +2133,8 @@ void init_gmpz()
 
   // Initializing, Assigning Integers
   rb_define_singleton_method(cGMP_Z, "new", r_gmpzsg_new, -1);
-  rb_define_method(cGMP_Z, "initialize", r_gmpz_initialize, -1);
-  rb_define_method(cGMP_Z, "swap",  r_gmpz_swap, 1);
+  rb_define_method(cGMP_Z, "initialize",    r_gmpz_initialize, -1);
+  rb_define_method(cGMP_Z, "swap",          r_gmpz_swap, 1);
 
   // Converting Integers
   rb_define_method(cGMP_Z, "to_i", r_gmpz_to_i, 0);
@@ -2032,6 +2148,7 @@ void init_gmpz()
   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, "submul!", r_gmpz_submul_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);
@@ -2040,14 +2157,17 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "abs!",    r_gmpz_abs_self, 0);
   
   // Integer Division
-  rb_define_method(cGMP_Z, "/",    r_gmpz_div, 1);
-  rb_define_method(cGMP_Z, "tdiv", r_gmpz_tdiv, 1);
-  rb_define_method(cGMP_Z, "tmod", r_gmpz_tmod, 1);
-  rb_define_method(cGMP_Z, "fdiv", r_gmpz_fdiv, 1);
-  rb_define_method(cGMP_Z, "fmod", r_gmpz_fmod, 1);
-  rb_define_method(cGMP_Z, "cdiv", r_gmpz_cdiv, 1);
-  rb_define_method(cGMP_Z, "cmod", r_gmpz_cmod, 1);
-  rb_define_method(cGMP_Z, "%",    r_gmpz_mod, 1);
+  rb_define_method(cGMP_Z, "/",            r_gmpz_div, 1);
+  rb_define_method(cGMP_Z, "tdiv",         r_gmpz_tdiv, 1);
+  rb_define_method(cGMP_Z, "tmod",         r_gmpz_tmod, 1);
+  rb_define_method(cGMP_Z, "tshr",         r_gmpz_tshr, 1);
+  rb_define_method(cGMP_Z, "lastbits_sgn", r_gmpz_tshrm, 1);
+  rb_define_method(cGMP_Z, "fdiv",         r_gmpz_fdiv, 1);
+  rb_define_method(cGMP_Z, "fmod",         r_gmpz_fmod, 1);
+  rb_define_method(cGMP_Z, "cdiv",         r_gmpz_cdiv, 1);
+  rb_define_method(cGMP_Z, "cmod",         r_gmpz_cmod, 1);
+  rb_define_method(cGMP_Z, "%",            r_gmpz_mod, 1);
+  rb_define_method(cGMP_Z, "divisible?",   r_gmpz_divisible, 1);
   
   // Integer Exponentiation
   rb_define_singleton_method(cGMP_Z, "pow",    r_gmpzsg_pow, 2);
@@ -2069,6 +2189,7 @@ void init_gmpz()
   rb_define_alias(           cGMP_Z, "next_prime",    "nextprime");
   rb_define_alias(           cGMP_Z, "next_prime!",   "nextprime!");
   rb_define_method(          cGMP_Z, "gcd",           r_gmpz_gcd, 1);
+  rb_define_method(          cGMP_Z, "gcdext",        r_gmpz_gcdext, 1);
   rb_define_method(          cGMP_Z, "invert",        r_gmpz_invert, 1);
   rb_define_method(          cGMP_Z, "jacobi",        r_gmpz_jacobi, 1);
   rb_define_singleton_method(cGMP_Z, "jacobi",        r_gmpzsg_jacobi, 2);
@@ -2114,8 +2235,6 @@ void init_gmpz()
   
   // _unsorted_
   rb_define_method(cGMP_Z, ">>",  r_gmpz_fshr, 1);
-  rb_define_method(cGMP_Z, "tshr",  r_gmpz_tshr, 1);
-  rb_define_method(cGMP_Z, "lastbits_sgn",  r_gmpz_tshrm, 1);
   rb_define_method(cGMP_Z, "lastbits_pos",  r_gmpz_fshrm, 1);
 
 }