gmp 0.2.2 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/ext/gmpz.c CHANGED
@@ -30,6 +30,8 @@
30
30
  * fmod r_gmpz_fmod mpz_fdiv_r
31
31
  * cdiv r_gmpz_cdiv mpz_cdiv_q
32
32
  * cmod r_gmpz_cmod mpz_cdiv_r
33
+ * % r_gmpz_mod mpz_mod
34
+ * \------------------------ mpz_mod_ui
33
35
  * -@ r_gmpz_neg mpz_neg
34
36
  * neg r_gmpz_neg mpz_neg
35
37
  * neg! r_gmpz_neg_self mpz_neg
@@ -46,6 +48,9 @@
46
48
  * probab_prime? r_gmpz_is_probab_prime mpz_probab_prime_p
47
49
  * nextprime r_gmpz_nextprime mpz_nextprime
48
50
  * nextprime! r_gmpz_nextprime_self mpz_nextprime
51
+ * gcd r_gmpz_gcd mpz_gcd
52
+ * \------------------------ mpz_gcd_ui
53
+ * invert r_gmpz_invert mpz_invert
49
54
  * jacobi r_gmpz_jacobi mpz_jacobi
50
55
  * #jacobi r_gmpzsg_jacobi mpz_jacobi
51
56
  * legendre r_gmpz_legendre mpz_legendre
@@ -60,14 +65,11 @@
60
65
  * scan1 r_gmpz_scan1 mpz_scan1
61
66
  * even? r_gmpz_is_even mpz_even
62
67
  * odd? r_gmpz_is_odd mpz_odd
68
+ * sizeinbase r_gmpz_sizeinbase mpz_sizeinbase
69
+ * size_in_bin r_gmpz_size_in_bin mpz_sizeinbits
63
70
  * ...
64
71
  */
65
72
 
66
- /*
67
- * The goal is to organize this file in the same order that the GMP Manual
68
- * is organized.
69
- */
70
-
71
73
  /**********************************************************************
72
74
  * Macros *
73
75
  **********************************************************************/
@@ -222,9 +224,9 @@ static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg) \
222
224
 
223
225
  /*
224
226
  * call-seq:
225
- * GMP::Z.new(arg)
227
+ * GMP::Z.new(arg = 0)
226
228
  *
227
- * Creates a new GMP::Z integer, with arg as its value, converting where
229
+ * Creates a new GMP::Z integer, with +arg+ as its value, converting where
228
230
  * necessary.
229
231
  */
230
232
  VALUE r_gmpzsg_new(int argc, VALUE *argv, VALUE klass)
@@ -239,7 +241,6 @@ VALUE r_gmpzsg_new(int argc, VALUE *argv, VALUE klass)
239
241
 
240
242
  mpz_make_struct(res, res_val);
241
243
  mpz_init(res_val);
242
-
243
244
  rb_obj_call_init(res, argc, argv);
244
245
 
245
246
  return res;
@@ -715,9 +716,12 @@ DEFUN_INT2INT(abs, mpz_abs)
715
716
 
716
717
  /*
717
718
  * call-seq:
718
- * /(other)
719
+ * a / b
719
720
  *
720
- * Divides this GMP::Z by other. Other can be
721
+ * Divides _a_ by _b_. Combines the different GMP division functions to
722
+ * provide what one is hopefully looking for. The result will either be
723
+ * an instance of GMP::Q or GMP::F, depending on _b_. _b_ can be an
724
+ * instance of any of the following:
721
725
  * * GMP::Z
722
726
  * * Fixnum
723
727
  * * GMP::Q
@@ -732,48 +736,48 @@ VALUE r_gmpz_div(VALUE self, VALUE arg)
732
736
  VALUE res;
733
737
  unsigned int prec;
734
738
 
735
- mpz_get_struct(self,self_val);
739
+ mpz_get_struct (self,self_val);
736
740
 
737
- if (GMPZ_P(arg)) {
738
- mpz_get_struct(arg, arg_val_z);
739
- if (mpz_cmp_ui(arg_val_z, 0) == 0)
740
- rb_raise(rb_eZeroDivError, "divided by 0");
741
- mpq_make_struct_init(res, res_val_q);
742
- mpq_set_num(res_val_q, self_val);
743
- mpq_set_den(res_val_q, arg_val_z);
741
+ if (GMPZ_P (arg)) {
742
+ mpz_get_struct (arg, arg_val_z);
743
+ if (mpz_cmp_ui (arg_val_z, 0) == 0)
744
+ rb_raise (rb_eZeroDivError, "divided by 0");
745
+ mpq_make_struct_init (res, res_val_q);
746
+ mpq_set_num (res_val_q, self_val);
747
+ mpq_set_den (res_val_q, arg_val_z);
744
748
  mpq_canonicalize (res_val_q);
745
- } else if (FIXNUM_P(arg)) {
746
- if (FIX2INT(arg) == 0)
747
- rb_raise(rb_eZeroDivError, "divided by 0");
748
- mpq_make_struct_init(res, res_val_q);
749
- mpq_set_num(res_val_q, self_val);
750
- mpz_set_ui(mpq_denref(res_val_q), FIX2INT(arg));
749
+ } else if (FIXNUM_P (arg)) {
750
+ if (FIX2INT (arg) == 0)
751
+ rb_raise (rb_eZeroDivError, "divided by 0");
752
+ mpq_make_struct_init (res, res_val_q);
753
+ mpq_set_num (res_val_q, self_val);
754
+ mpz_set_ui (mpq_denref (res_val_q), FIX2INT (arg));
751
755
  mpq_canonicalize (res_val_q);
752
- } else if (GMPQ_P(arg)) {
753
- mpq_get_struct(arg, arg_val_q);
754
- if (mpz_cmp_ui(mpq_numref(arg_val_q), 0) == 0)
755
- rb_raise(rb_eZeroDivError, "divided by 0");
756
- mpz_temp_init(tmp_z);
757
- mpq_make_struct_init(res, res_val_q);
758
- mpz_gcd(tmp_z, mpq_numref(arg_val_q), self_val);
759
- mpz_divexact(mpq_numref(res_val_q), self_val, tmp_z);
760
- mpz_divexact(mpq_denref(res_val_q), mpq_numref(arg_val_q), tmp_z);
761
- mpz_mul(mpq_numref(res_val_q), mpq_numref(res_val_q), mpq_denref(arg_val_q));
762
- mpz_temp_free(tmp_z);
756
+ } else if (GMPQ_P (arg)) {
757
+ mpq_get_struct (arg, arg_val_q);
758
+ if (mpz_cmp_ui (mpq_numref (arg_val_q), 0) == 0)
759
+ rb_raise (rb_eZeroDivError, "divided by 0");
760
+ mpz_temp_init (tmp_z);
761
+ mpq_make_struct_init (res, res_val_q);
762
+ mpz_gcd (tmp_z, mpq_numref (arg_val_q), self_val);
763
+ mpz_divexact (mpq_numref (res_val_q), self_val, tmp_z);
764
+ mpz_divexact (mpq_denref (res_val_q), mpq_numref (arg_val_q), tmp_z);
765
+ mpz_mul (mpq_numref (res_val_q), mpq_numref (res_val_q), mpq_denref (arg_val_q));
766
+ mpz_temp_free (tmp_z);
763
767
  } else if (GMPF_P(arg)) {
764
- mpf_get_struct_prec(arg, arg_val_f, prec);
765
- mpf_make_struct_init(res, res_val_f, prec);
766
- mpf_set_z(res_val_f, self_val);
767
- mpf_div(res_val_f, res_val_f, arg_val_f);
768
- } else if (BIGNUM_P(arg)) {
769
- mpq_make_struct_init(res, res_val_q);
770
- mpz_set_bignum(mpq_denref(res_val_q), arg);
771
- if (mpz_cmp_ui(mpq_denref(res_val_q), 0) == 0)
772
- rb_raise(rb_eZeroDivError, "divided by 0");
773
- mpq_set_num(res_val_q, self_val);
774
- mpq_canonicalize(res_val_q);
768
+ mpf_get_struct_prec (arg, arg_val_f, prec);
769
+ mpf_make_struct_init (res, res_val_f, prec);
770
+ mpf_set_z (res_val_f, self_val);
771
+ mpf_div (res_val_f, res_val_f, arg_val_f);
772
+ } else if (BIGNUM_P (arg)) {
773
+ mpq_make_struct_init (res, res_val_q);
774
+ mpz_set_bignum (mpq_denref (res_val_q), arg);
775
+ if (mpz_cmp_ui (mpq_denref (res_val_q), 0) == 0)
776
+ rb_raise (rb_eZeroDivError, "divided by 0");
777
+ mpq_set_num (res_val_q, self_val);
778
+ mpq_canonicalize (res_val_q);
775
779
  } else {
776
- typeerror(ZQFXB);
780
+ typeerror (ZQFXB);
777
781
  }
778
782
  return res;
779
783
  }
@@ -884,6 +888,39 @@ DEFUN_INT_DIV(cdiv, mpz_cdiv_q)
884
888
  */
885
889
  DEFUN_INT_DIV(cmod, mpz_cdiv_r)
886
890
 
891
+ /*
892
+ * call-seq:
893
+ * a % b
894
+ *
895
+ * Returns _a_ mod _b_. _b_ can be an instance any of the following:
896
+ * * GMP::Z
897
+ * * Fixnum
898
+ * * Bignum
899
+ */
900
+ VALUE r_gmpz_mod(VALUE self, VALUE arg)
901
+ {
902
+ MP_INT *self_val, *arg_val, *res_val;
903
+ VALUE res;
904
+
905
+ mpz_get_struct(self,self_val);
906
+
907
+ if (GMPZ_P(arg)) {
908
+ mpz_make_struct_init(res, res_val);
909
+ mpz_get_struct(arg, arg_val);
910
+ mpz_mod(res_val, self_val, arg_val);
911
+ } else if (FIXNUM_P(arg)) {
912
+ mpz_make_struct_init(res, res_val);
913
+ mpz_mod_ui(res_val, self_val, FIX2INT(arg));
914
+ } else if (BIGNUM_P(arg)) {
915
+ mpz_make_struct_init(res, res_val);
916
+ mpz_set_bignum(res_val, arg);
917
+ mpz_mod(res_val, res_val, self_val);
918
+ } else {
919
+ typeerror(ZXB);
920
+ }
921
+ return res;
922
+ }
923
+
887
924
 
888
925
  /**********************************************************************
889
926
  * Integer Exponentiation *
@@ -1137,6 +1174,56 @@ VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self)
1137
1174
  */
1138
1175
  DEFUN_INT2INT(nextprime, mpz_nextprime)
1139
1176
 
1177
+ VALUE r_gmpz_gcd(VALUE self, VALUE arg)
1178
+ {
1179
+ MP_INT *self_val, *arg_val, *res_val;
1180
+ VALUE res;
1181
+
1182
+ mpz_get_struct (self,self_val);
1183
+
1184
+ if (GMPZ_P (arg)) {
1185
+ mpz_make_struct_init (res, res_val);
1186
+ mpz_get_struct (arg, arg_val);
1187
+ mpz_gcd (res_val, self_val, arg_val);
1188
+ } else if (FIXNUM_P (arg)) {
1189
+ mpz_make_struct_init (res, res_val);
1190
+ mpz_gcd_ui (res_val, self_val, FIX2INT(arg));
1191
+ } else if (BIGNUM_P (arg)) {
1192
+ mpz_make_struct_init (res, res_val);
1193
+ mpz_set_bignum (res_val, arg);
1194
+ mpz_gcd (res_val, res_val, self_val);
1195
+ } else {
1196
+ typeerror (ZXB);
1197
+ }
1198
+ return res;
1199
+ }
1200
+
1201
+ VALUE r_gmpz_invert(VALUE self, VALUE arg)
1202
+ {
1203
+ MP_INT *self_val, *arg_val, *res_val;
1204
+ VALUE res;
1205
+
1206
+ mpz_get_struct (self,self_val);
1207
+
1208
+ if (GMPZ_P (arg)) {
1209
+ mpz_make_struct_init (res, res_val);
1210
+ mpz_get_struct (arg, arg_val);
1211
+ mpz_invert (res_val, self_val, arg_val);
1212
+ } else if (FIXNUM_P (arg)) {
1213
+ mpz_temp_alloc(arg_val);
1214
+ mpz_init_set_ui(arg_val, FIX2INT(arg));
1215
+ mpz_make_struct_init (res, res_val);
1216
+ mpz_invert (res_val, self_val, arg_val);
1217
+ } else if (BIGNUM_P (arg)) {
1218
+ mpz_make_struct_init (res, res_val);
1219
+ mpz_set_bignum (res_val, arg);
1220
+ mpz_invert (res_val, res_val, self_val);
1221
+ } else {
1222
+ typeerror (ZXB);
1223
+ }
1224
+ return res;
1225
+ }
1226
+
1140
1227
  /*
1141
1228
  * Document-method: jacobi
1142
1229
  *
@@ -1322,7 +1409,7 @@ VALUE r_gmpz_remove(VALUE self, VALUE arg)
1322
1409
  * GMP::Z.fac(3) #=> 6
1323
1410
  * GMP::Z.fac(4) #=> 24
1324
1411
  */
1325
- DEFUN_INT_SINGLETON_UI(fac,mpz_fac_ui)
1412
+ DEFUN_INT_SINGLETON_UI(fac, mpz_fac_ui)
1326
1413
  /*
1327
1414
  * Document-method: GMP::Z.fib
1328
1415
  *
@@ -1343,7 +1430,7 @@ DEFUN_INT_SINGLETON_UI(fac,mpz_fac_ui)
1343
1430
  * GMP::Z.fac(6) #=> 8
1344
1431
  * GMP::Z.fac(7) #=> 13
1345
1432
  */
1346
- DEFUN_INT_SINGLETON_UI(fib,mpz_fib_ui)
1433
+ DEFUN_INT_SINGLETON_UI(fib, mpz_fib_ui)
1347
1434
 
1348
1435
 
1349
1436
  /**********************************************************************
@@ -1545,17 +1632,17 @@ VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to)
1545
1632
  MP_INT *self_val;
1546
1633
  int bitnr_val;
1547
1634
 
1548
- mpz_get_struct(self, self_val);
1635
+ mpz_get_struct (self, self_val);
1549
1636
 
1550
- if (FIXNUM_P(bitnr)) {
1637
+ if (FIXNUM_P (bitnr)) {
1551
1638
  bitnr_val = FIX2INT (bitnr);
1552
1639
  } else {
1553
- typeerror_as(X, "index");
1640
+ typeerror_as (X, "index");
1554
1641
  }
1555
- if (RTEST(set_to)) {
1556
- mpz_setbit(self_val, bitnr_val);
1642
+ if (RTEST (set_to)) {
1643
+ mpz_setbit (self_val, bitnr_val);
1557
1644
  } else {
1558
- mpz_clrbit(self_val, bitnr_val);
1645
+ mpz_clrbit (self_val, bitnr_val);
1559
1646
  }
1560
1647
  return Qnil;
1561
1648
  }
@@ -1580,14 +1667,27 @@ VALUE r_gmpz_getbit(VALUE self, VALUE bitnr)
1580
1667
  }
1581
1668
 
1582
1669
 
1583
- /**********************************************************************
1584
- * Integer Random Numbers *
1585
- **********************************************************************/
1586
-
1587
1670
  /**********************************************************************
1588
1671
  * Miscellaneous Integer Functions *
1589
1672
  **********************************************************************/
1590
1673
 
1674
+ VALUE r_gmpz_sizeinbase(VALUE self, VALUE base)
1675
+ {
1676
+ MP_INT *self_val;
1677
+ int base_val;
1678
+ mpz_get_struct (self, self_val);
1679
+ base_val = FIX2INT (base);
1680
+ return INT2FIX (mpz_sizeinbase (self_val, base_val));
1681
+ }
1682
+
1683
+ VALUE r_gmpz_size_in_bin(VALUE self)
1684
+ {
1685
+ MP_INT *self_val;
1686
+ mpz_get_struct (self, self_val);
1687
+ return INT2FIX (mpz_sizeinbase (self_val, 2));
1688
+ }
1689
+
1690
+
1591
1691
  /**********************************************************************
1592
1692
  * Integer Special Functions *
1593
1693
  **********************************************************************/
@@ -1800,6 +1900,7 @@ void init_gmpz()
1800
1900
  rb_define_method(cGMP_Z, "fmod", r_gmpz_fmod, 1);
1801
1901
  rb_define_method(cGMP_Z, "cdiv", r_gmpz_cdiv, 1);
1802
1902
  rb_define_method(cGMP_Z, "cmod", r_gmpz_cmod, 1);
1903
+ rb_define_method(cGMP_Z, "%", r_gmpz_mod, 1);
1803
1904
 
1804
1905
  // Integer Exponentiation
1805
1906
  rb_define_singleton_method(cGMP_Z, "pow", r_gmpzsg_pow, 2);
@@ -1820,6 +1921,8 @@ void init_gmpz()
1820
1921
  rb_define_method( cGMP_Z, "nextprime!", r_gmpz_nextprime_self, 0);
1821
1922
  rb_define_alias( cGMP_Z, "next_prime", "nextprime");
1822
1923
  rb_define_alias( cGMP_Z, "next_prime!", "nextprime!");
1924
+ rb_define_method( cGMP_Z, "gcd", r_gmpz_gcd, 1);
1925
+ rb_define_method( cGMP_Z, "invert", r_gmpz_invert, 1);
1823
1926
  rb_define_method( cGMP_Z, "jacobi", r_gmpz_jacobi, 1);
1824
1927
  rb_define_singleton_method(cGMP_Z, "jacobi", r_gmpzsg_jacobi, 2);
1825
1928
  rb_define_method( cGMP_Z, "legendre", r_gmpz_legendre, 1);
@@ -1835,7 +1938,7 @@ void init_gmpz()
1835
1938
  rb_define_method(cGMP_Z, "<=", r_gmpz_cmp_le, 1);
1836
1939
  rb_define_method(cGMP_Z, "cmpabs", r_gmpz_cmpabs, 1);
1837
1940
 
1838
- // _unsorted_
1941
+ // Integer Logic and Bit Fiddling
1839
1942
  rb_define_method(cGMP_Z, "com", r_gmpz_com, 0);
1840
1943
  rb_define_method(cGMP_Z, "com!", r_gmpz_com_self, 0);
1841
1944
  rb_define_method(cGMP_Z, "&", r_gmpz_and, 1);
@@ -1845,10 +1948,16 @@ void init_gmpz()
1845
1948
  rb_define_method(cGMP_Z, "[]", r_gmpz_getbit, 1);
1846
1949
  rb_define_method(cGMP_Z, "scan0", r_gmpz_scan0, 1);
1847
1950
  rb_define_method(cGMP_Z, "scan1", r_gmpz_scan1, 1);
1951
+
1952
+ //Miscellaneous Integer Functions
1953
+ rb_define_method(cGMP_Z, "sizeinbase", r_gmpz_sizeinbase, 1);
1954
+ rb_define_alias( cGMP_Z, "size_in_base", "sizeinbase");
1955
+ rb_define_method(cGMP_Z, "size_in_bin", r_gmpz_size_in_bin, 0);
1956
+
1957
+ // _unsorted_
1848
1958
  rb_define_method(cGMP_Z, "even?", r_gmpz_is_even, 0);
1849
1959
  rb_define_method(cGMP_Z, "odd?", r_gmpz_is_odd, 0);
1850
1960
  rb_define_method(cGMP_Z, "sgn", r_gmpz_sgn, 0);
1851
-
1852
1961
  rb_define_method(cGMP_Z, "==", r_gmpz_eq, 1);
1853
1962
  rb_define_method(cGMP_Z, ">>", r_gmpz_fshr, 1);
1854
1963
  rb_define_method(cGMP_Z, "tshr", r_gmpz_tshr, 1);
data/ext/ruby_gmp.h CHANGED
@@ -34,13 +34,21 @@ typedef __mpfr_struct MP_FLOAT;
34
34
  typedef __mpf_struct MP_FLOAT;
35
35
  #endif /* HAVE_MPF2MPFR_H */
36
36
 
37
+ /*
38
+ I don't like this solution, because in gmp.h, all of these typedefs are
39
+ marked with "gmp 1 source compatibility". :(.
40
+ */
41
+ typedef __gmp_randstate_struct MP_RANDSTATE;
42
+
37
43
  #define mpz_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_INT, c_var); }
38
44
  #define mpq_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RAT, c_var); }
39
45
  #define mpf_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_FLOAT, c_var); }
46
+ #define mprandstate_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RANDSTATE, c_var); }
40
47
  #define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpf_get_prec(c_var); }
41
48
  #define mpz_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Z, MP_INT, 0, r_gmpz_free, c_var); }
42
49
  #define mpq_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Q, MP_RAT, 0, r_gmpq_free, c_var); }
43
50
  #define mpf_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_F, MP_FLOAT, 0, r_gmpf_free, c_var); }
51
+ #define mprandstate_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_RandState, MP_RANDSTATE, 0, r_gmprandstate_free, c_var); }
44
52
  #define mpz_make_struct_init(ruby_var,c_var) { mpz_make_struct(ruby_var,c_var); mpz_init (c_var); }
45
53
  #define mpq_make_struct_init(ruby_var,c_var) { mpq_make_struct(ruby_var,c_var); mpq_init (c_var); }
46
54
  #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;
74
82
  //should change exception type
75
83
  #define not_yet rb_raise(rb_eTypeError,"Not implemented yet")
76
84
 
77
- extern VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F;
85
+ extern VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F, cGMP_RandState;
78
86
 
79
87
  extern void r_gmpz_free(void *ptr);
80
88
  extern void r_gmpq_free(void *ptr);
81
89
  extern void r_gmpf_free(void *ptr);
90
+ extern void r_gmprandstate_free(void *ptr);
82
91
 
83
92
 
84
93
  /* from gmpz.h */
@@ -102,11 +111,16 @@ extern VALUE r_gmpz_sub(VALUE self, VALUE arg);
102
111
  extern VALUE r_gmpz_sub_self(VALUE self, VALUE arg);
103
112
  extern VALUE r_gmpz_mul(VALUE self, VALUE arg);
104
113
 
114
+ // Integer Division
115
+ extern VALUE r_gmpz_mod(VALUE self, VALUE arg);
116
+
105
117
  // Integer Exponentiation
106
118
  extern VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp);
107
119
 
108
120
  // Number Theoretic Functions
109
121
  extern VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self);
122
+ extern VALUE r_gmpz_gcd(VALUE self, VALUE arg);
123
+ extern VALUE r_gmpz_invert(VALUE self, VALUE arg);
110
124
  extern VALUE r_gmpz_jacobi(VALUE self, VALUE b);
111
125
  extern VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b);
112
126
  extern VALUE r_gmpz_legendre(VALUE self, VALUE p);
@@ -117,6 +131,10 @@ extern VALUE r_gmpz_eq(VALUE self, VALUE arg);
117
131
  extern VALUE r_gmpz_cmp(VALUE self, VALUE arg);
118
132
  extern VALUE r_gmpz_cmpabs(VALUE self, VALUE arg);
119
133
 
134
+ // Miscelaneous Integer Functions
135
+ extern VALUE r_gmpz_sizeinbase(VALUE self, VALUE base);
136
+ extern VALUE r_gmpz_size_in_bin(VALUE self);
137
+
120
138
  // _unsorted_
121
139
  extern VALUE r_gmpz_div(VALUE self, VALUE arg);
122
140
  extern VALUE r_gmpz_popcount(VALUE self);
@@ -194,8 +212,32 @@ extern VALUE r_gmpf_sgn(VALUE self);
194
212
  extern VALUE r_gmpf_get_prec(VALUE self);
195
213
 
196
214
 
215
+ /* from gmprandstate.h */
216
+
217
+ // Random State Initialization
218
+ extern VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass);
219
+ extern VALUE r_gmprandstate_initialize(int argc, VALUE *argv, VALUE self);
220
+ extern VALUE r_gmpmod_randstate(int argc, VALUE *argv, VALUE module);
221
+
222
+ // Random State Seeding
223
+ extern VALUE r_gmprandstate_seed(VALUE self, VALUE arg);
224
+
225
+ // Integer Random Numbers
226
+ extern VALUE r_gmprandstate_urandomb(VALUE self, VALUE arg);
227
+
228
+
229
+ /* from gmpbench_timing.c */
230
+
231
+ // GMPbench Timing
232
+ extern VALUE r_gmpmod_cputime(VALUE self);
233
+ extern VALUE r_gmpmod_time(VALUE self);
234
+
235
+
236
+
197
237
  extern void init_gmpz();
198
238
  extern void init_gmpq();
199
239
  extern void init_gmpf();
240
+ extern void init_gmprandstate();
241
+ extern void init_gmpbench_timing();
200
242
 
201
243
  #endif