gmp 0.2.2 → 0.4.0

data/ext/gmpz.c

@@ -30,6 +30,8 @@
  *   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
@@ -46,6 +48,9 @@
  *   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
@@ -60,14 +65,11 @@
  *   scan1          r_gmpz_scan1            mpz_scan1
  *   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
  *   ...
  */
 
-/*
- * The goal is to organize this file in the same order that the GMP Manual
- * is organized.
- */
-
 /**********************************************************************
  *    Macros                                                          *
  **********************************************************************/
@@ -222,9 +224,9 @@ static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg)     \
 
 /*
  * call-seq:
- *   GMP::Z.new(arg)
+ *   GMP::Z.new(arg = 0)
  *
- * Creates a new GMP::Z integer, with arg as its value, converting where
+ * Creates a new GMP::Z integer, with +arg+ as its value, converting where
  * necessary.
  */
 VALUE r_gmpzsg_new(int argc, VALUE *argv, VALUE klass)
@@ -239,7 +241,6 @@ VALUE r_gmpzsg_new(int argc, VALUE *argv, VALUE klass)
 
   mpz_make_struct(res, res_val);
   mpz_init(res_val);
-
   rb_obj_call_init(res, argc, argv);
 
   return res;
@@ -715,9 +716,12 @@ DEFUN_INT2INT(abs, mpz_abs)
 
 /*
  * call-seq:
- *   /(other)
+ *   a / b
  *
- * Divides this GMP::Z by other. Other can be
+ * 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:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -732,48 +736,48 @@ VALUE r_gmpz_div(VALUE self, VALUE arg)
   VALUE res;
   unsigned int prec;
 
-  mpz_get_struct(self,self_val);
+  mpz_get_struct (self,self_val);
 
-  if (GMPZ_P(arg)) {
-    mpz_get_struct(arg, arg_val_z);
-    if (mpz_cmp_ui(arg_val_z, 0) == 0)
-      rb_raise(rb_eZeroDivError, "divided by 0");
-    mpq_make_struct_init(res, res_val_q);
-    mpq_set_num(res_val_q, self_val);
-    mpq_set_den(res_val_q, arg_val_z);
+  if (GMPZ_P (arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    if (mpz_cmp_ui (arg_val_z, 0) == 0)
+      rb_raise (rb_eZeroDivError, "divided by 0");
+    mpq_make_struct_init (res, res_val_q);
+    mpq_set_num (res_val_q, self_val);
+    mpq_set_den (res_val_q, arg_val_z);
     mpq_canonicalize (res_val_q);
-  } else if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) == 0)
-      rb_raise(rb_eZeroDivError, "divided by 0");
-    mpq_make_struct_init(res, res_val_q);
-    mpq_set_num(res_val_q, self_val);
-    mpz_set_ui(mpq_denref(res_val_q), FIX2INT(arg));
+  } else if (FIXNUM_P (arg)) {
+    if (FIX2INT (arg) == 0)
+      rb_raise (rb_eZeroDivError, "divided by 0");
+    mpq_make_struct_init (res, res_val_q);
+    mpq_set_num (res_val_q, self_val);
+    mpz_set_ui (mpq_denref (res_val_q), FIX2INT (arg));
     mpq_canonicalize (res_val_q);
-  } else if (GMPQ_P(arg)) {
-    mpq_get_struct(arg, arg_val_q);
-    if (mpz_cmp_ui(mpq_numref(arg_val_q), 0) == 0)
-      rb_raise(rb_eZeroDivError, "divided by 0");
-    mpz_temp_init(tmp_z);
-    mpq_make_struct_init(res, res_val_q);
-    mpz_gcd(tmp_z, mpq_numref(arg_val_q), self_val);
-    mpz_divexact(mpq_numref(res_val_q), self_val, tmp_z);
-    mpz_divexact(mpq_denref(res_val_q), mpq_numref(arg_val_q), tmp_z);
-    mpz_mul(mpq_numref(res_val_q), mpq_numref(res_val_q), mpq_denref(arg_val_q));
-    mpz_temp_free(tmp_z);
+  } else if (GMPQ_P (arg)) {
+    mpq_get_struct (arg, arg_val_q);
+    if (mpz_cmp_ui (mpq_numref (arg_val_q), 0) == 0)
+      rb_raise (rb_eZeroDivError, "divided by 0");
+    mpz_temp_init (tmp_z);
+    mpq_make_struct_init (res, res_val_q);
+    mpz_gcd (tmp_z, mpq_numref (arg_val_q), self_val);
+    mpz_divexact (mpq_numref (res_val_q), self_val, tmp_z);
+    mpz_divexact (mpq_denref (res_val_q), mpq_numref (arg_val_q), tmp_z);
+    mpz_mul (mpq_numref (res_val_q), mpq_numref (res_val_q), mpq_denref (arg_val_q));
+    mpz_temp_free (tmp_z);
   } else if (GMPF_P(arg)) {
-    mpf_get_struct_prec(arg, arg_val_f, prec);
-    mpf_make_struct_init(res, res_val_f, prec);
-    mpf_set_z(res_val_f, self_val);
-    mpf_div(res_val_f, res_val_f, arg_val_f);
-  } else if (BIGNUM_P(arg)) {
-    mpq_make_struct_init(res, res_val_q);
-    mpz_set_bignum(mpq_denref(res_val_q), arg);
-    if (mpz_cmp_ui(mpq_denref(res_val_q), 0) == 0)
-      rb_raise(rb_eZeroDivError, "divided by 0");
-    mpq_set_num(res_val_q, self_val);
-    mpq_canonicalize(res_val_q);
+    mpf_get_struct_prec (arg, arg_val_f, prec);
+    mpf_make_struct_init (res, res_val_f, prec);
+    mpf_set_z (res_val_f, self_val);
+    mpf_div (res_val_f, res_val_f, arg_val_f);
+  } else if (BIGNUM_P (arg)) {
+    mpq_make_struct_init (res, res_val_q);
+    mpz_set_bignum (mpq_denref (res_val_q), arg);
+    if (mpz_cmp_ui (mpq_denref (res_val_q), 0) == 0)
+      rb_raise (rb_eZeroDivError, "divided by 0");
+    mpq_set_num (res_val_q, self_val);
+    mpq_canonicalize (res_val_q);
   } else {
-    typeerror(ZQFXB);
+    typeerror (ZQFXB);
   }
   return res;
 }
@@ -884,6 +888,39 @@ DEFUN_INT_DIV(cdiv, mpz_cdiv_q)
  */
 DEFUN_INT_DIV(cmod, mpz_cdiv_r)
 
+/*
+ * call-seq:
+ *   a % b
+ *
+ * Returns _a_ mod _b_. _b_ can be an instance any of the following:
+ * * GMP::Z
+ * * Fixnum
+ * * Bignum
+ */
+VALUE r_gmpz_mod(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val, *res_val;
+  VALUE res;
+
+  mpz_get_struct(self,self_val);
+
+  if (GMPZ_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_get_struct(arg, arg_val);
+    mpz_mod(res_val, self_val, arg_val);
+  } else if (FIXNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_mod_ui(res_val, self_val, FIX2INT(arg));
+  } else if (BIGNUM_P(arg)) {
+    mpz_make_struct_init(res, res_val);
+    mpz_set_bignum(res_val, arg);
+    mpz_mod(res_val, res_val, self_val);
+  } else {
+    typeerror(ZXB);
+  }
+  return res;
+}
+
 
 /**********************************************************************
  *    Integer Exponentiation                                          *
@@ -1137,6 +1174,56 @@ VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self)
  */
 DEFUN_INT2INT(nextprime, mpz_nextprime)
 
+VALUE r_gmpz_gcd(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val, *res_val;
+  VALUE res;
+
+  mpz_get_struct (self,self_val);
+
+  if (GMPZ_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_get_struct (arg, arg_val);
+    mpz_gcd (res_val, self_val, arg_val);
+  } else if (FIXNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_gcd_ui (res_val, self_val, FIX2INT(arg));
+  } else if (BIGNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_set_bignum (res_val, arg);
+    mpz_gcd (res_val, res_val, self_val);
+  } else {
+    typeerror (ZXB);
+  }
+  return res;
+}
+
+VALUE r_gmpz_invert(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val, *res_val;
+  VALUE res;
+
+  mpz_get_struct (self,self_val);
+
+  if (GMPZ_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_get_struct (arg, arg_val);
+    mpz_invert (res_val, self_val, arg_val);
+  } else if (FIXNUM_P (arg)) {
+    mpz_temp_alloc(arg_val);
+    mpz_init_set_ui(arg_val, FIX2INT(arg));
+    mpz_make_struct_init (res, res_val);
+    mpz_invert (res_val, self_val, arg_val);
+  } else if (BIGNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_set_bignum (res_val, arg);
+    mpz_invert (res_val, res_val, self_val);
+  } else {
+    typeerror (ZXB);
+  }
+  return res;
+}
+
 /*
  * Document-method: jacobi
  *
@@ -1322,7 +1409,7 @@ VALUE r_gmpz_remove(VALUE self, VALUE arg)
  * GMP::Z.fac(3)  #=>  6
  * GMP::Z.fac(4)  #=> 24
  */
-DEFUN_INT_SINGLETON_UI(fac,mpz_fac_ui)
+DEFUN_INT_SINGLETON_UI(fac, mpz_fac_ui)
 /*
  * Document-method: GMP::Z.fib
  *
@@ -1343,7 +1430,7 @@ DEFUN_INT_SINGLETON_UI(fac,mpz_fac_ui)
  * GMP::Z.fac(6)  #=>  8
  * GMP::Z.fac(7)  #=> 13
  */
-DEFUN_INT_SINGLETON_UI(fib,mpz_fib_ui)
+DEFUN_INT_SINGLETON_UI(fib, mpz_fib_ui)
 
 
 /**********************************************************************
@@ -1545,17 +1632,17 @@ VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to)
   MP_INT *self_val;
   int bitnr_val;
 
-  mpz_get_struct(self, self_val);
+  mpz_get_struct (self, self_val);
 
-  if (FIXNUM_P(bitnr)) {
+  if (FIXNUM_P (bitnr)) {
     bitnr_val = FIX2INT (bitnr);
   } else {
-    typeerror_as(X, "index");
+    typeerror_as (X, "index");
   }
-  if (RTEST(set_to)) {
-    mpz_setbit(self_val, bitnr_val);
+  if (RTEST (set_to)) {
+    mpz_setbit (self_val, bitnr_val);
   } else {
-    mpz_clrbit(self_val, bitnr_val);
+    mpz_clrbit (self_val, bitnr_val);
   }
   return Qnil;
 }
@@ -1580,14 +1667,27 @@ VALUE r_gmpz_getbit(VALUE self, VALUE bitnr)
 }
 
 
-/**********************************************************************
- *    Integer Random Numbers                                          *
- **********************************************************************/
-
 /**********************************************************************
  *    Miscellaneous Integer Functions                                 *
  **********************************************************************/
 
+VALUE r_gmpz_sizeinbase(VALUE self, VALUE base)
+{
+  MP_INT *self_val;
+  int base_val;
+  mpz_get_struct (self, self_val);
+  base_val = FIX2INT (base);
+  return INT2FIX (mpz_sizeinbase (self_val, base_val));
+}
+
+VALUE r_gmpz_size_in_bin(VALUE self)
+{
+  MP_INT *self_val;
+  mpz_get_struct (self, self_val);
+  return INT2FIX (mpz_sizeinbase (self_val, 2));
+}
+
+
 /**********************************************************************
  *    Integer Special Functions                                       *
  **********************************************************************/
@@ -1800,6 +1900,7 @@ void init_gmpz()
   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);
   
   // Integer Exponentiation
   rb_define_singleton_method(cGMP_Z, "pow",    r_gmpzsg_pow, 2);
@@ -1820,6 +1921,8 @@ void init_gmpz()
   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, "gcd",           r_gmpz_gcd, 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);
   rb_define_method(          cGMP_Z, "legendre",      r_gmpz_legendre, 1);
@@ -1835,7 +1938,7 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "<=",  r_gmpz_cmp_le, 1);
   rb_define_method(cGMP_Z, "cmpabs",  r_gmpz_cmpabs, 1);
   
-  // _unsorted_
+  // Integer Logic and Bit Fiddling
   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);
@@ -1845,10 +1948,16 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "[]", r_gmpz_getbit, 1);
   rb_define_method(cGMP_Z, "scan0", r_gmpz_scan0, 1);
   rb_define_method(cGMP_Z, "scan1", r_gmpz_scan1, 1);
+  
+  //Miscellaneous Integer Functions
+  rb_define_method(cGMP_Z, "sizeinbase", r_gmpz_sizeinbase, 1);
+  rb_define_alias( cGMP_Z, "size_in_base", "sizeinbase");
+  rb_define_method(cGMP_Z, "size_in_bin", r_gmpz_size_in_bin, 0);
+  
+  // _unsorted_
   rb_define_method(cGMP_Z, "even?", r_gmpz_is_even, 0);
   rb_define_method(cGMP_Z, "odd?", r_gmpz_is_odd, 0);
   rb_define_method(cGMP_Z, "sgn", r_gmpz_sgn, 0);
-  
   rb_define_method(cGMP_Z, "==",  r_gmpz_eq, 1);
   rb_define_method(cGMP_Z, ">>",  r_gmpz_fshr, 1);
   rb_define_method(cGMP_Z, "tshr",  r_gmpz_tshr, 1);

data/ext/ruby_gmp.h

@@ -34,13 +34,21 @@ typedef __mpfr_struct MP_FLOAT;
 typedef __mpf_struct MP_FLOAT;
 #endif /* HAVE_MPF2MPFR_H */
 
+/*
+  I don't like this solution, because in gmp.h, all of these typedefs are
+  marked with "gmp 1 source compatibility". :(.
+*/
+typedef __gmp_randstate_struct MP_RANDSTATE;
+
 #define mpz_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_INT, c_var); }
 #define mpq_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RAT, c_var); }
 #define mpf_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_FLOAT, c_var); }
+#define mprandstate_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RANDSTATE, c_var); }
 #define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpf_get_prec(c_var); }
 #define mpz_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Z, MP_INT, 0, r_gmpz_free, c_var); }
 #define mpq_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Q, MP_RAT, 0, r_gmpq_free, c_var); }
 #define mpf_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_F, MP_FLOAT, 0, r_gmpf_free, c_var); }
+#define mprandstate_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_RandState, MP_RANDSTATE, 0, r_gmprandstate_free, c_var); }
 #define mpz_make_struct_init(ruby_var,c_var) { mpz_make_struct(ruby_var,c_var); mpz_init (c_var); }
 #define mpq_make_struct_init(ruby_var,c_var) { mpq_make_struct(ruby_var,c_var); mpq_init (c_var); }
 #define mpf_make_struct_init(ruby_var,c_var,prec) { mpf_make_struct(ruby_var,c_var); mpf_init2 (c_var,prec); }
@@ -74,11 +82,12 @@ typedef __mpf_struct MP_FLOAT;
 //should change exception type
 #define not_yet rb_raise(rb_eTypeError,"Not implemented yet")
 
-extern VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F;
+extern VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F, cGMP_RandState;
 
 extern void r_gmpz_free(void *ptr);
 extern void r_gmpq_free(void *ptr);
 extern void r_gmpf_free(void *ptr);
+extern void r_gmprandstate_free(void *ptr);
 
 
 /* from gmpz.h */
@@ -102,11 +111,16 @@ extern VALUE r_gmpz_sub(VALUE self, VALUE arg);
 extern VALUE r_gmpz_sub_self(VALUE self, VALUE arg);
 extern VALUE r_gmpz_mul(VALUE self, VALUE arg);
 
+// Integer Division
+extern VALUE r_gmpz_mod(VALUE self, VALUE arg);
+
 // Integer Exponentiation
 extern VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp);
 
 // Number Theoretic Functions
 extern VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self);
+extern VALUE r_gmpz_gcd(VALUE self, VALUE arg);
+extern VALUE r_gmpz_invert(VALUE self, VALUE arg);
 extern VALUE r_gmpz_jacobi(VALUE self, VALUE b);
 extern VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b);
 extern VALUE r_gmpz_legendre(VALUE self, VALUE p);
@@ -117,6 +131,10 @@ extern VALUE r_gmpz_eq(VALUE self, VALUE arg);
 extern VALUE r_gmpz_cmp(VALUE self, VALUE arg);
 extern VALUE r_gmpz_cmpabs(VALUE self, VALUE arg);
 
+// Miscelaneous Integer Functions
+extern VALUE r_gmpz_sizeinbase(VALUE self, VALUE base);
+extern VALUE r_gmpz_size_in_bin(VALUE self);
+
 // _unsorted_
 extern VALUE r_gmpz_div(VALUE self, VALUE arg);
 extern VALUE r_gmpz_popcount(VALUE self);
@@ -194,8 +212,32 @@ extern VALUE r_gmpf_sgn(VALUE self);
 extern VALUE r_gmpf_get_prec(VALUE self);
 
 
+/* from gmprandstate.h */
+
+// Random State Initialization
+extern VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass);
+extern VALUE r_gmprandstate_initialize(int argc, VALUE *argv, VALUE self);
+extern VALUE r_gmpmod_randstate(int argc, VALUE *argv, VALUE module);
+
+// Random State Seeding
+extern VALUE r_gmprandstate_seed(VALUE self, VALUE arg);
+
+// Integer Random Numbers
+extern VALUE r_gmprandstate_urandomb(VALUE self, VALUE arg);
+
+
+/* from gmpbench_timing.c */
+
+// GMPbench Timing
+extern VALUE r_gmpmod_cputime(VALUE self);
+extern VALUE r_gmpmod_time(VALUE self);
+
+
+
 extern void init_gmpz();
 extern void init_gmpq();
 extern void init_gmpf();
+extern void init_gmprandstate();
+extern void init_gmpbench_timing();
 
 #endif