gmp 0.2.1 → 0.2.2

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.2.2:
+  * GMP::Z.jacobi and GPM::Z#jacobi work and are tested.
+  * GMP::Z.legendre works and is tested.
+  * GMP::Z.next_prime is an alias for GMP::Z.nextprime.
+  * GMP::Z.next_prime! is an alias for GMP::Z.nextprime!.
+  * GMP::Z.remove works as it is supposed to.
+  * PDF documentation is extended.
+
 0.2.1:
   * Got GMP::F(Fixnum) working, (I think it already was).
   * More and more documentation in PDF.

data/README.rdoc

@@ -47,7 +47,7 @@ paragraph at http://gmplib.org/#WHAT :
   contributors to sign paperwork where they allow us to distribute their work."
 
 Only GMP 4 or newer is supported. The following environments have been tested by me:
-  gmp gem 0.1.4.2 on:
+  gmp gem 0.2.2 on:
   +-------------------------------------+-------------------+-----------+
   |    Platform                         |       Ruby        |    GMP    |
   +-------------------------------------+-------------------+-----------+
@@ -77,8 +77,8 @@ Constructors can take following arguments:
 
   GMP::Z.new()
   GMP::Z.new(GMP::Z)
-  GMP::Z.new(FixNum)
-  GMP::Z.new(BigNum)
+  GMP::Z.new(Fixnum)
+  GMP::Z.new(Bignum)
   GMP::Z.new(String)
   GMP::Q.new()
   GMP::Q.new(GMP::Q)
@@ -91,14 +91,14 @@ Constructors can take following arguments:
   GMP::F.new(GMP::F)
   GMP::F.new(GMP::F, precision)
   GMP::F.new(String, precision=0)
-  GMP::F.new(FixNum, precision=0)
-  GMP::F.new(BigNum, precision=0)
+  GMP::F.new(Fixnum, precision=0)
+  GMP::F.new(Bignum, precision=0)
   GMP::F.new(Float,  precision=0)
 
 You can also call them as:
-        GMP.Z(args)
-        GMP.Q(args)
-        GMP.F(args)
+  GMP.Z(args)
+  GMP.Q(args)
+  GMP.F(args)
 
 =Methods
 

data/ext/gmpf.c

@@ -10,6 +10,17 @@
  * 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.
+ *
+ * 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_gmpf_to_d             mpf_get_d
+ *   to_s           r_gmpf_to_s             mpf_get_s
+ *   +              r_gmpf_add              mpf_add
+ *   -              r_gmpf_sub              mpf_sub
+ *   *              r_gmpf_mul              mpf_mul
+ *   /              r_gmpf_div              mpf_div
  */
 
 /**********************************************************************
@@ -379,33 +390,33 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
   mpf_get_struct_prec (self, self_val, prec);
 
   if (GMPF_P(arg)) {
-    mpf_get_struct (arg, arg_val_f);
+    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);
+    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);
+    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);
+    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);
+    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, NUM2DBL(arg));
-    mpf_div (res_val, self_val, res_val);
+    mpf_set_d(res_val, NUM2DBL(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);
+    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, self_val, res_val);	
+    mpf_set_z(res_val, arg_val_z);
+    mpf_div(res_val, self_val, res_val);	
     mpz_temp_free(arg_val_z);
   } else {
     typeerror(ZQFXBD);

data/ext/gmpq.c

@@ -21,6 +21,11 @@
  *   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
  */
 
 /**********************************************************************

data/ext/gmpz.c

@@ -14,42 +14,52 @@
  * 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
- *   add!         r_gmpz_add_self       mpz_add
- *   -            r_gmpz_sub            mpz_sub
- *   sub!         r_gmpz_sub_self       mpz_sub
- *   *            r_gmpz_mul            mpz_mul
- *   /            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_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
- *   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
- *   remove       r_gmpz_remove         mpz_remove
- *   fac          r_gmpz_fac            mpz_fac_ui
- *   fib          r_gmpz_fib            mpz_fib_ui
- *   com          r_gmpz_com            mpz_com
- *   com!         r_gmpz_com_self       mpz_com
- *   []=          r_gmpz_setbit         mpz_setbit
- *   []           r_gmpz_getbit         mpz_tstbit
- *   scan0        r_gmpz_scan0          mpz_scan0
- *   scan1        r_gmpz_scan1          mpz_scan1
- *   even?        r_gmpz_is_even        mpz_even
- *   odd?         r_gmpz_is_odd         mpz_odd
+ *   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
+ *   add!           r_gmpz_add_self         mpz_add
+ *   -              r_gmpz_sub              mpz_sub
+ *   sub!           r_gmpz_sub_self         mpz_sub
+ *   *              r_gmpz_mul              mpz_mul
+ *   /              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_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
+ *   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
+ *   com            r_gmpz_com              mpz_com
+ *   com!           r_gmpz_com_self         mpz_com
+ *   []=            r_gmpz_setbit           mpz_setbit
+ *   []             r_gmpz_getbit           mpz_tstbit
+ *   scan0          r_gmpz_scan0            mpz_scan0
+ *   scan1          r_gmpz_scan1            mpz_scan1
+ *   even?          r_gmpz_is_even          mpz_even
+ *   odd?           r_gmpz_is_odd           mpz_odd
  *   ...
  */
 
@@ -78,7 +88,7 @@ static VALUE r_gmpz_##fname##_self(VALUE self) \
   MP_INT *self_val;                            \
   mpz_get_struct(self, self_val);              \
   mpz_fname(self_val, self_val);               \
-  return Qnil;                                 \
+  return self;                                 \
 }
 
 #define DEFUN_INT_F_UL(fname,mpz_fname,argname)          \
@@ -641,6 +651,19 @@ VALUE r_gmpz_mul(VALUE self, VALUE arg)
   return res;
 }
 
+/*
+ * Document-method: <<
+ *
+ * call-seq:
+ *   integer << 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.
+ */
+DEFUN_INT_F_UL(shl,mpz_mul_2exp,"shift size")
+
 /*
  * Document-method: neg
  *
@@ -866,6 +889,90 @@ DEFUN_INT_DIV(cmod, mpz_cdiv_r)
  *    Integer Exponentiation                                          *
  **********************************************************************/
 
+/*
+ * Document-method: **
+ *
+ * call-seq:
+ *   integer ** exp
+ *
+ * From the GMP Manual:
+ * 
+ * Returns +integer+ raised to +exp+. The case 0^0 yields 1.
+ */
+DEFUN_INT_F_UL(pow,mpz_pow_ui,"exponent")
+
+/*
+ * call-seq:
+ *   integer.powmod(exp, mod)
+ *
+ * From the GMP Manual:
+ * 
+ * Returns +integer+ raised to +exp+ modulo +mod+.
+ *
+ * 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.
+ */
+VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod)
+{
+  MP_INT *self_val, *res_val, *mod_val, *exp_val;
+  VALUE res;
+  int free_mod_val = 0;
+
+  if (GMPZ_P(mod)) {
+    mpz_get_struct(mod, mod_val);
+    if (mpz_sgn(mod_val) <= 0) {
+      rb_raise(rb_eRangeError, "modulus must be positive");
+    }
+  } else if (FIXNUM_P(mod)) {
+    if (FIX2INT(mod) <= 0) {
+      rb_raise(rb_eRangeError, "modulus must be positive");
+    }
+    mpz_temp_alloc(mod_val);
+    mpz_init_set_ui(mod_val, FIX2INT(mod));
+    free_mod_val = 1;
+  } else if (BIGNUM_P(mod)) {
+    mpz_temp_from_bignum(mod_val, mod);
+    if (mpz_sgn(mod_val) <= 0) {
+      mpz_temp_free(mod_val);
+      rb_raise(rb_eRangeError, "modulus must be positive");
+    }
+    free_mod_val = 1;
+  } else {
+    typeerror_as(ZXB, "modulus");
+  }
+  mpz_make_struct_init(res, res_val);
+  mpz_get_struct(self, self_val);
+
+  if (GMPZ_P(exp)) {
+    mpz_get_struct(exp, exp_val);
+    if (mpz_sgn(mod_val) < 0) {
+      rb_raise(rb_eRangeError, "exponent must be nonnegative");
+    }
+    mpz_powm(res_val, self_val, exp_val, mod_val);
+  } else if (FIXNUM_P(exp)) {
+    if (FIX2INT(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);
+  } else if (BIGNUM_P(exp)) {
+    mpz_temp_from_bignum(exp_val, exp);
+    mpz_powm(res_val, self_val, exp_val, mod_val);
+    mpz_temp_free(exp_val);
+  } else {
+    if (free_mod_val)
+      mpz_temp_free(mod_val);
+    typeerror_as(ZXB, "exponent");
+  }
+  if (free_mod_val)
+    mpz_temp_free(mod_val);
+  return res;
+}
+
+
 /**********************************************************************
  *    Integer Roots                                                   *
  **********************************************************************/
@@ -928,11 +1035,227 @@ static VALUE r_gmpz_sqrtrem(VALUE self)
   return rb_assoc_new(sqrt, rem);
 }
 
+/*
+ * Document-method: power?
+ *
+ * call-seq:
+ *   integer.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.
+ *
+ * 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?
+ *
+ * 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.
+ */
+DEFUN_INT_COND_P(is_square,mpz_perfect_square_p)
+
 
 /**********************************************************************
  *    Number Theoretic Functions                                      *
  **********************************************************************/
 
+/*
+ * call-seq: 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.
+ *
+ * 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.
+ */
+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);
+  if(NIL_P(reps)){
+    reps = INT2FIX(5);
+  }
+  if (FIXNUM_P(reps)) {
+    reps_val = FIX2INT (reps);
+  } else {
+    typeerror_as(X, "reps");
+  }
+  return INT2FIX(mpz_probab_prime_p(self_val, reps_val));
+}
+
+/*
+ * Document-method: nextprime
+ *
+ * call-seq:
+ *   integer.nextprime
+ *   integer.next_prime
+ *
+ * From the GMP Manual:
+ * 
+ * Returns the next prime greater than +integer+.
+ *
+ * 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!
+ *
+ * From the GMP Manual:
+ * 
+ * Sets +integer+ to the next prime greater than +integer+.
+ *
+ * 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)
+
+/*
+ * 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.
+ */
+VALUE r_gmpz_jacobi(VALUE self, VALUE b)
+{
+  MP_INT *self_val, *b_val;
+  int res_val;
+  mpz_get_struct(self, self_val);
+  mpz_get_struct(   b,    b_val);
+  if (mpz_sgn(b_val) != 1)
+    rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is non-positive.");
+  if (mpz_even_p(b_val))
+    rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is even.");
+  res_val = mpz_jacobi(self_val, b_val);
+  return INT2FIX(res_val);
+}
+
+/*
+ * 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.
+ */
+VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b)
+{
+  MP_INT *a_val, *b_val;
+  int res_val;
+  int free_a_val = 0;
+  int free_b_val = 0;
+  (void)klass;
+  
+  if (GMPZ_P(a)) {
+    mpz_get_struct(a, a_val);
+  } else if (FIXNUM_P(a)) {
+    mpz_temp_alloc(a_val);
+    mpz_init_set_ui(a_val, FIX2INT(a));
+    free_a_val = 1;
+  } else if (BIGNUM_P(a)) {
+    mpz_temp_from_bignum(a_val, a);
+    free_a_val = 1;
+  } else {
+    typeerror_as(ZXB, "a");
+  }
+  
+  if (GMPZ_P(b)) {
+    mpz_get_struct(b, b_val);
+    if (mpz_sgn(b_val) != 1)
+      rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is non-positive.");
+    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)
+      rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is non-positive.");
+    if (FIX2INT(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));
+    free_b_val = 1;
+  } else if (BIGNUM_P(b)) {
+    mpz_temp_from_bignum(b_val, b);
+    if (mpz_sgn(b_val) != 1) {
+      mpz_temp_free(b_val);
+      rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is non-positive.");
+    }
+    if (mpz_even_p(b_val)) {
+      mpz_temp_free(b_val);
+      rb_raise(rb_eRangeError, "Cannot take Jacobi symbol (a/b) where b is even.");
+    }
+    free_b_val = 1;
+  } else {
+    typeerror_as(ZXB, "b");
+  }
+  
+  res_val = mpz_jacobi(a_val, b_val);
+  if (free_a_val) { mpz_temp_free(a_val); }
+  if (free_b_val) { mpz_temp_free(b_val); }
+  return INT2FIX(res_val);
+}
+
+/*
+ * 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. 
+ */
+VALUE r_gmpz_legendre(VALUE self, VALUE p)
+{
+  MP_INT *self_val, *p_val;
+  int res_val;
+  mpz_get_struct(self, self_val);
+  mpz_get_struct(   p,    p_val);
+  if (mpz_sgn(p_val) != 1)
+    rb_raise(rb_eRangeError, "Cannot take Legendre symbol (a/p) where p is non-positive.");
+  if (mpz_even_p(p_val))
+    rb_raise(rb_eRangeError, "Cannot take Legendre symbol (a/p) where p is even.");
+  if (mpz_probab_prime_p(p_val, 5) == 0)
+    rb_raise(rb_eRangeError, "Cannot take Legendre symbol (a/p) where p is composite.");
+  res_val = mpz_legendre(self_val, p_val);
+  return INT2FIX(res_val);
+}
+
 /*
  * Document-method: remove
  *
@@ -948,9 +1271,10 @@ VALUE r_gmpz_remove(VALUE self, VALUE arg)
 {
   MP_INT *self_val, *arg_val, *res_val;
   VALUE res;
+  int   removed_val;
   int free_arg_val = 0;
 
-  mpz_get_struct(self,self_val);
+  mpz_get_struct(self, self_val);
 
   if (GMPZ_P(arg)) {
     mpz_get_struct(arg,arg_val);
@@ -964,20 +1288,20 @@ VALUE r_gmpz_remove(VALUE self, VALUE arg)
   } else if (BIGNUM_P(arg)) {
     mpz_temp_from_bignum(arg_val, arg);
     if (mpz_sgn(arg_val) != 1) {
-      mpz_temp_free (arg_val);
+      mpz_temp_free(arg_val);
       rb_raise(rb_eRangeError, "argument must be positive");
     }
   } else {
     typeerror(ZXB);
   }
 
-  mpz_make_struct_init (res, res_val);
-  mpz_remove (res_val, self_val, arg_val);
+  mpz_make_struct_init(res, res_val);
+  removed_val = mpz_remove(res_val, self_val, arg_val);
 
   if (free_arg_val)
     mpz_temp_free(arg_val);
 
-  return res;
+  return rb_assoc_new(res, INT2FIX(removed_val));
 }
 
 /*
@@ -1190,110 +1514,6 @@ VALUE r_gmpz_scan1(VALUE self, VALUE bitnr)
   return INT2FIX(mpz_scan1(self_val, bitnr_val));
 }
 
-
-/**********************************************************************
- *    Integer Random Numbers                                          *
- **********************************************************************/
-
-/**********************************************************************
- *    Miscellaneous Integer Functions                                 *
- **********************************************************************/
-
-/**********************************************************************
- *    Integer Special Functions                                       *
- **********************************************************************/
-
-
-/**********************************************************************
- *    _unsorted_                                                      *
- **********************************************************************/
-
-/*
- * Document-method: com
- *
- * call-seq:
- *   integer.com
- *
- * From the GMP Manual:
- * 
- * Returns the one's complement of +integer+.
- */
-/*
- * Document-method: com!
- *
- * call-seq:
- *   integer.com!
- *
- * From the GMP Manual:
- * 
- * Sets +integer+ to its one's complement.
- */
-DEFUN_INT2INT(com, mpz_com)
-/*
- * Document-method: nextprime
- *
- * call-seq:
- *   integer.nextprime
- *
- * From the GMP Manual:
- * 
- * Returns the next prime greater than +integer+.
- *
- * 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!
- *
- * From the GMP Manual:
- * 
- * Sets +integer+ to the next prime greater than +integer+.
- *
- * 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: probab_prime?([reps])
- *
- * Determine whether +n+ is prime. Returns 2 if +n+ is definitely prime,
- * returns 1 if +n+ is probably prime (without being certain), or return 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�.
- *
- * 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)
-{
-  MP_INT *self_val;
-  int reps_val;
-  VALUE reps;
-  mpz_get_struct(self, self_val);
-  rb_scan_args(argc, argv, "01", &reps);
-  if(NIL_P(reps)){
-    reps = INT2FIX(5);
-  }
-  if (FIXNUM_P(reps)) {
-    reps_val = FIX2INT (reps);
-  } else {
-    typeerror_as(X, "reps");
-  }
-  return INT2FIX(mpz_probab_prime_p(self_val, reps_val));
-}
-
 /*
  * Document-method: popcount
  *
@@ -1314,60 +1534,6 @@ VALUE r_gmpz_popcount(VALUE self)
   return INT2FIX(mpz_popcount(self_val));
 }
 
-/*
- * Document-method: jacobi
- *
- * call-seq:
- *   a.jacobi
- *
- * <b>90% sure this is incorrectly implemented. Todo.</b>
- *
- * From the GMP Manual:
- * 
- * Calculate the Jacobi symbol <tt>(a/b)</tt>. This is defined only for +b+
- * odd.
- */
-VALUE r_gmpz_jacobi(VALUE self)
-{
-  MP_INT *self_val, *res_val;
-  VALUE res;
-  mpz_get_struct(self, self_val);
-  if (mpz_sgn(self_val) != 1)
-    rb_raise(rb_eRangeError, "you can take jacobi symbol only of positive value");
-  if (mpz_even_p(self_val))
-    rb_raise(rb_eRangeError, "you can't take jacobi symbol of even value");
-  mpz_make_struct_init(res, res_val);
-  mpz_jacobi(res_val, self_val);
-  return res;
-}
-
-/*
- * Document-method: legendre
- *
- * call-seq:
- *   a.legendre
- *
- * <b>90% sure this is incorrectly implemented. Todo.</b>
- *
- * 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. 
- */
-VALUE r_gmpz_legendre(VALUE self)
-{
-  MP_INT *self_val, *res_val;
-  VALUE res;
-  mpz_get_struct(self, self_val);
-  if (mpz_sgn(self_val) != 1)
-    rb_raise(rb_eRangeError, "you can take legendre symbol only of positive value");
-  if (mpz_even_p(self_val))
-    rb_raise(rb_eRangeError, "you can't take legendre symbol of even value");
-    mpz_make_struct_init(res, res_val);
-  mpz_legendre(res_val, self_val);
-  return res;
-}
-
 /*
  * call-seq:
  *   integer[index] = x &rarr; nil
@@ -1413,57 +1579,68 @@ VALUE r_gmpz_getbit(VALUE self, VALUE bitnr)
   return mpz_tstbit(self_val, bitnr_val)?Qtrue:Qfalse;
 }
 
+
+/**********************************************************************
+ *    Integer Random Numbers                                          *
+ **********************************************************************/
+
+/**********************************************************************
+ *    Miscellaneous Integer Functions                                 *
+ **********************************************************************/
+
+/**********************************************************************
+ *    Integer Special Functions                                       *
+ **********************************************************************/
+
+
+/**********************************************************************
+ *    _unsorted_                                                      *
+ **********************************************************************/
+
 /*
- * Document-method: even?
+ * Document-method: com
  *
  * call-seq:
- *   integer.even?
+ *   integer.com
  *
  * From the GMP Manual:
  * 
- * Determines whether integer is even. Returns true or false.
+ * Returns the one's complement of +integer+.
  */
-DEFUN_INT_COND_P(is_even,mpz_even_p)
 /*
- * Document-method: odd?
+ * Document-method: com!
  *
  * call-seq:
- *   integer.odd?
+ *   integer.com!
  *
  * From the GMP Manual:
  * 
- * Determines whether integer is odd. Returns true or false.
+ * Sets +integer+ to its one's complement.
  */
-DEFUN_INT_COND_P(is_odd,mpz_odd_p)
+DEFUN_INT2INT(com, mpz_com)
+
 /*
- * Document-method: square?
+ * Document-method: even?
  *
  * call-seq:
- *   integer.square?
+ *   integer.even?
  *
  * 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.
+ * Determines whether integer is even. Returns true or false.
  */
-DEFUN_INT_COND_P(is_square,mpz_perfect_square_p)
+DEFUN_INT_COND_P(is_even,mpz_even_p)
 /*
- * Document-method: power?
+ * Document-method: odd?
  *
  * call-seq:
- *   integer.square?
+ *   integer.odd?
  *
  * 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.
- *
- * 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.
+ * Determines whether integer is odd. Returns true or false.
  */
-DEFUN_INT_COND_P(is_power,mpz_perfect_power_p)
+DEFUN_INT_COND_P(is_odd,mpz_odd_p)
 
 /*
  * call-seq:
@@ -1480,100 +1657,6 @@ VALUE r_gmpz_sgn(VALUE self)
   return INT2FIX(mpz_sgn(self_val));
 }
 
-/*
- * call-seq:
- *   integer.powmod(exp, mod)
- *
- * From the GMP Manual:
- * 
- * Returns +integer+ raised to +exp+ modulo +mod+.
- *
- * 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.
- */
-VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod)
-{
-  MP_INT *self_val, *res_val, *mod_val, *exp_val;
-  VALUE res;
-  int free_mod_val = 0;
-
-  if (GMPZ_P(mod)) {
-    mpz_get_struct(mod, mod_val);
-    if (mpz_sgn(mod_val) <= 0) {
-      rb_raise (rb_eRangeError, "modulus must be positive");
-    }
-  } else if (FIXNUM_P(mod)) {
-  if (FIX2INT(mod) <= 0) {
-    rb_raise (rb_eRangeError, "modulus must be positive");
-  }
-  mpz_temp_alloc (mod_val);
-  mpz_init_set_ui(mod_val, FIX2INT(mod));
-  free_mod_val = 1;
-  } else if (BIGNUM_P(mod)) {
-    mpz_temp_from_bignum (mod_val, mod);
-    if (mpz_sgn(mod_val) <= 0) {
-      mpz_temp_free(mod_val);
-      rb_raise (rb_eRangeError, "modulus must be positive");
-    }
-    free_mod_val = 1;
-  } else {
-    typeerror_as (ZXB, "modulus");
-  }
-  mpz_make_struct_init(res, res_val);
-  mpz_get_struct(self, self_val);
-
-  if (GMPZ_P(exp)) {
-    mpz_get_struct(exp, exp_val);
-    if (mpz_sgn(mod_val) < 0) {
-      rb_raise (rb_eRangeError, "exponent must be nonnegative");
-    }
-    mpz_powm (res_val, self_val, exp_val, mod_val);
-  } else if (FIXNUM_P(exp)) {
-    if (FIX2INT(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);
-  } else if (BIGNUM_P(exp)) {
-    mpz_temp_from_bignum (exp_val, exp);
-    mpz_powm (res_val, self_val, exp_val, mod_val);
-    mpz_temp_free (exp_val);
-  } else {
-    if (free_mod_val)
-      mpz_temp_free(mod_val);
-    typeerror_as (ZXB, "exponent");
-  }
-  if (free_mod_val)
-    mpz_temp_free(mod_val);
-  return res;
-}
-
-/*
- * Document-method: **
- *
- * call-seq:
- *   integer ** exp
- *
- * From the GMP Manual:
- * 
- * Returns +integer+ raised to +exp+. The case 0^0 yields 1.
- */
-DEFUN_INT_F_UL(pow,mpz_pow_ui,"exponent")
-/*
- * Document-method: <<
- *
- * call-seq:
- *   integer << 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.
- */
-DEFUN_INT_F_UL(shl,mpz_mul_2exp,"shift size")
 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")
@@ -1697,16 +1780,20 @@ 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, "+",    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, "-",    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, "neg", r_gmpz_neg, 0);
+  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);
   
   // Integer Division
-  rb_define_method(cGMP_Z, "/", r_gmpz_div, 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, "fdiv", r_gmpz_fdiv, 1);
@@ -1715,15 +1802,30 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "cmod", r_gmpz_cmod, 1);
   
   // Integer Exponentiation
-  rb_define_singleton_method(cGMP_Z, "pow", r_gmpzsg_pow, 2);
+  rb_define_singleton_method(cGMP_Z, "pow",    r_gmpzsg_pow, 2);
+  rb_define_method(cGMP_Z,           "**",     r_gmpz_pow, 1);
+  rb_define_method(cGMP_Z,           "powmod", r_gmpz_powm, 2);
 
   // Integer Roots
-  rb_define_method(cGMP_Z, "root",  r_gmpz_root, 1);
+  rb_define_method(cGMP_Z, "root",    r_gmpz_root, 1);
+  rb_define_method(cGMP_Z, "sqrt",    r_gmpz_sqrt, 0);
+  rb_define_method(cGMP_Z, "sqrt!",   r_gmpz_sqrt_self, 0);
+  rb_define_method(cGMP_Z, "sqrtrem", r_gmpz_sqrtrem, 0);
+  rb_define_method(cGMP_Z, "square?", r_gmpz_is_square, 0);
+  rb_define_method(cGMP_Z, "power?",  r_gmpz_is_power, 0);
   
   // Number Theoretic Functions
-  rb_define_method(cGMP_Z, "remove",  r_gmpz_remove, 1);
-  rb_define_singleton_method(cGMP_Z, "fac", r_gmpzsg_fac, 1);
-  rb_define_singleton_method(cGMP_Z, "fib", r_gmpzsg_fib, 1);
+  rb_define_method(          cGMP_Z, "probab_prime?", r_gmpz_is_probab_prime, -1);
+  rb_define_method(          cGMP_Z, "nextprime",     r_gmpz_nextprime, 0);
+  rb_define_method(          cGMP_Z, "nextprime!",    r_gmpz_nextprime_self, 0);
+  rb_define_alias(           cGMP_Z, "next_prime",    "nextprime");
+  rb_define_alias(           cGMP_Z, "next_prime!",   "nextprime!");
+  rb_define_method(          cGMP_Z, "jacobi",        r_gmpz_jacobi, 1);
+  rb_define_singleton_method(cGMP_Z, "jacobi",        r_gmpzsg_jacobi, 2);
+  rb_define_method(          cGMP_Z, "legendre",      r_gmpz_legendre, 1);
+  rb_define_method(          cGMP_Z, "remove",        r_gmpz_remove, 1);
+  rb_define_singleton_method(cGMP_Z, "fac",           r_gmpzsg_fac, 1);
+  rb_define_singleton_method(cGMP_Z, "fib",           r_gmpzsg_fib, 1);
   
   // Integer Comparisons
   rb_define_method(cGMP_Z, "<=>", r_gmpz_cmp, 1);
@@ -1734,9 +1836,6 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "cmpabs",  r_gmpz_cmpabs, 1);
   
   // _unsorted_
-  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, "com", r_gmpz_com, 0);
   rb_define_method(cGMP_Z, "com!", r_gmpz_com_self, 0);
   rb_define_method(cGMP_Z, "&", r_gmpz_and, 1);
@@ -1750,25 +1849,11 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "odd?", r_gmpz_is_odd, 0);
   rb_define_method(cGMP_Z, "sgn", r_gmpz_sgn, 0);
   
-  rb_define_method(cGMP_Z, "**", r_gmpz_pow, 1);
-  rb_define_method(cGMP_Z, "powmod", r_gmpz_powm, 2);
-  
   rb_define_method(cGMP_Z, "==",  r_gmpz_eq, 1);
   rb_define_method(cGMP_Z, ">>",  r_gmpz_fshr, 1);
-  rb_define_method(cGMP_Z, "<<",  r_gmpz_shl, 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);
-  rb_define_method(cGMP_Z, "square?",  r_gmpz_is_square, 0);
-  rb_define_method(cGMP_Z, "power?",  r_gmpz_is_power, 0);
-  rb_define_method(cGMP_Z, "sqrt",  r_gmpz_sqrt, 0);
-  rb_define_method(cGMP_Z, "sqrt!",  r_gmpz_sqrt_self, 0);
-  rb_define_method(cGMP_Z, "sqrtrem",  r_gmpz_sqrtrem, 0);
-  rb_define_method(cGMP_Z, "jacobi",  r_gmpz_jacobi, 0);
-  rb_define_method(cGMP_Z, "legendre",  r_gmpz_legendre, 0);
-  rb_define_method(cGMP_Z, "probab_prime?",  r_gmpz_is_probab_prime, -1);
-  rb_define_method(cGMP_Z, "nextprime",  r_gmpz_nextprime, 0);
-  rb_define_method(cGMP_Z, "nextprime!",  r_gmpz_nextprime_self, 0);
   rb_define_method(cGMP_Z, "popcount",  r_gmpz_popcount, 0);
 
 }