gmp 0.6.7 → 0.6.13

data/CHANGELOG

@@ -1,3 +1,11 @@
+0.6.13:
+  * Added three new GMP::Z methods for GMP 5.1.x: GMP::Z#2fac
+    (GMP::Z#double_fac), GMP::Z#mfac, and GMP::Z#primorial
+  * Fixed a compilation bug when MPFR is not available.
+  * Fixed test bugs when MPFR is not available.
+  * Tweaked README documentation
+  * Added GMP::Z method: GMP::Z#hamdist, with minimal tests
+
 0.6.7:
   * Added 9th set of Functional Mappings: GMP::Z.divisible?
   * Added 11th set of Functional Mappings: GMP::Z.congruent?

data/README.html

@@ -3,7 +3,8 @@
 <p>gmp is library providing Ruby bindings to GMP library. Here is the introduction
 paragraph at <a href="http://gmplib.org/#WHAT">their homepage</a>:</p>
 
-<blockquote><p>GMP is a free library for arbitrary precision arithmetic, operating on
+<blockquote>
+<p>GMP is a free library for arbitrary precision arithmetic, operating on
 signed integers, rational numbers, and floating point numbers. There is no
 practical limit to the precision except the ones implied by the available
 memory in the machine GMP runs on. GMP has a rich set of functions, and the
@@ -34,7 +35,7 @@ programs.</p>
 <p>GMP is part of the GNU project. For more information about the GNU project,
 please see the official GNU web site.</p>
 
-<p>GMP's main target platforms are Unix-type systems, such as GNU/Linux,
+<p>GMP&#39;s main target platforms are Unix-type systems, such as GNU/Linux,
 Solaris, HP-UX, Mac OS X/Darwin, BSD, AIX, etc. It also is known to work on
 Windoze in 32-bit mode.</p>
 
@@ -44,10 +45,11 @@ Windoze in 32-bit mode.</p>
 of course inspect and test contributed code carefully, but equally
 importantly we make sure we have the legal right to distribute the
 contributions, meaning users can safely use GMP. To achieve this, we will ask
-contributors to sign paperwork where they allow us to distribute their work."</p></blockquote>
+contributors to sign paperwork where they allow us to distribute their work.&quot;</p>
+</blockquote>
 
 <p>Only GMP 4 or newer is supported. The following environments have been tested
-by me: gmp gem 0.5.41 on:</p>
+by me: gmp gem 0.5.47 on:</p>
 
 <table border="1">
   <tr>
@@ -96,20 +98,15 @@ by me: gmp gem 0.5.41 on:</p>
         GMP 5.0.1 (3.0.0)</td>
   </tr>
   <tr>
-    <td rowspan="4">Mac OS X 10.6.4 on x86_64 (64-bit)</td>
+    <td rowspan="4">Mac OS X 10.6.8 on x86_64 (64-bit)</td>
     <td>(MRI) Ruby 1.8.7</td>
     <td>GMP 4.3.2 (2.4.2)<br />
-        GMP 5.0.1 (3.0.0)</td>
+        GMP 5.0.5 (3.1.1)</td>
   </tr>
   <tr>
-    <td>(MRI) Ruby 1.9.1</td>
-    <td>GMP 4.3.2 (2.4.2)<br />
-        GMP 5.0.1 (3.0.0)</td>
-  </tr>
-  <tr>
-    <td>(MRI) Ruby 1.9.2</td>
+    <td>(MRI) Ruby 1.9.3</td>
     <td>GMP 4.3.2 (2.4.2)<br />
-        GMP 5.0.1 (3.0.0)</td>
+        GMP 5.0.5 (3.1.1)</td>
   </tr>
   <tr>
     <td>(RBX) Rubinius 1.1.0</td>
@@ -140,7 +137,6 @@ by me: gmp gem 0.5.41 on:</p>
   </tr>
 </table>
 
-
 <h2>Authors</h2>
 
 <ul>
@@ -148,36 +144,34 @@ by me: gmp gem 0.5.41 on:</p>
 <li>srawlins</li>
 </ul>
 
-
 <h2>Constants</h2>
 
 <p>The GMP module includes the following constants. Mathematical constants, such
 as pi, are defined under class methods of GMP::F, listed below.</p>
 
 <ul>
-<li><code>GMP::GMP_VERSION</code> - A string like "5.0.1"</li>
+<li><code>GMP::GMP_VERSION</code> - A string like &quot;5.0.1&quot;</li>
 <li><code>GMP::GMP_CC</code> - The compiler used to compile GMP</li>
 <li><code>GMP::GMP_CFLAGS</code> - The CFLAGS used to compile GMP</li>
 <li><code>GMP::GMP\_BITS_PER_LIMB</code> The number of bits per limb</li>
 <li><code>GMP::GMP_NUMB_MAX</code> - The maximum value that can be stored in the number part of a limb</li>
 </ul>
 
-
 <p>if MPFR is available:
-* <code>GMP::MPFR_VERSION</code> - A string like "2.4.2"
+* <code>GMP::MPFR_VERSION</code> - A string like &quot;2.4.2&quot;
 * <code>GMP::MPFR\_PREC_MIN</code> - The minimum precision available
 * <code>GMP::MPFR_PREC_MAX</code> - The maximum precision available
-* <code>GMP::GMP_RNDN</code> - The constant representing "round to nearest"
-* <code>GMP::GMP_RNDZ</code> - The constant representing "round toward zero"
-* <code>GMP::GMP_RNDU</code> - The constant representing "round toward plus infinity"
-* <code>GMP::GMP_RNDD</code> - The constant representing "round toward minus infinity"</p>
+* <code>GMP::GMP_RNDN</code> - The constant representing &quot;round to nearest&quot;
+* <code>GMP::GMP_RNDZ</code> - The constant representing &quot;round toward zero&quot;
+* <code>GMP::GMP_RNDU</code> - The constant representing &quot;round toward plus infinity&quot;
+* <code>GMP::GMP_RNDD</code> - The constant representing &quot;round toward minus infinity&quot;</p>
 
 <p>New in MPFR 3.0.0:
 * <code>GMP::MPFR_RNDN</code>
 * <code>GMP::MPFR_RNDZ</code>
 * <code>GMP::MPFR_RNDU</code>
 * <code>GMP::MPFR_RNDD</code>
-* <code>GMP::MPFR_RNDA</code> - The constant representing "round away from zero"</p>
+* <code>GMP::MPFR_RNDA</code> - The constant representing &quot;round away from zero&quot;</p>
 
 <h2>Classes</h2>
 
@@ -239,6 +233,9 @@ GMP.RandState()
   &lt;=&gt;,&gt;=,&gt;,&lt;=,&lt;            comparisions
 class methods of GMP::Z
   fac(n)                   factorial of n
+  2fac(n), double_fac(n)   double factorial of n
+  mfac(n)                  m-multi-factorial of n
+  primorial(n)             primorial of n
   fib(n)                   nth fibonacci number
   pow(n,m)                 n to mth power
 GMP::Z and GMP::Q
@@ -263,8 +260,8 @@ GMP::Z
                            (respectively), then return the index of the
                            first instance.
   cmpabs                   comparison of absolute value
-  com                      2's complement
-  com!                     in-place 2's complement
+  com                      2&#39;s complement
+  com!                     in-place 2&#39;s complement
   &amp;,|,^                    logical operations: and, or, xor
   even?                    is even
   odd?                     is odd
@@ -282,12 +279,14 @@ GMP::Z
                            certainly prime
   nextprime                next *probable* prime
   nextprime!               change the object into its next *probable* prime
-  gcd, gcdext              greatest common divisor
+  gcd, gcdext, gcdext2     greatest common divisor
+  lcm                      least common multiple
   invert(m)                invert mod m
   jacobi                   jacobi symbol
   legendre                 legendre symbol
   remove(n)                remove all occurences of factor n
   popcount                 the number of bits equal to 1
+  hamdist                  the hamming distance between two integers
   sizeinbase(b)            digits in base b
   size_in_bin              digits in binary
   size                     number of limbs
@@ -342,7 +341,7 @@ GMP::F
   li2                      real part of the dilogarithm of object
   gamma                    Gamma fucntion of object
   lngamma                  logarithm of the Gamma function of object
-  digamma                  Digamma function of object (MPFR_VERSION &gt;= "3.0.0")
+  digamma                  Digamma function of object (MPFR_VERSION &gt;= &quot;3.0.0&quot;)
   zeta                     Reimann Zeta function of object
   erf                      error function of object
   erfc                     complementary error function of object
@@ -379,7 +378,7 @@ GMP::F
   infinite?                | type of floating point number
   finite?                  |
   number?                  |
-  regular?                 / (MPFR_VERSION &gt;= "3.0.0")
+  regular?                 / (MPFR_VERSION &gt;= &quot;3.0.0&quot;)
 GMP::RandState
   mpfr_urandomb(fixnum)    get uniformly distributed random floating-point
                            number within 0 &lt;= rop &lt; 1
@@ -387,7 +386,7 @@ GMP::RandState
 
 <h2>Functional Mappings</h2>
 
-<p>In order to align better with the GMP paradigms of using return arguments, I have started creating "functional mappings", singleton methods that map directly to functions in GMP. These methods take return arguments, so that passing an object to a functional mapping may change the object itself. For example:</p>
+<p>In order to align better with the GMP paradigms of using return arguments, I have started creating &quot;functional mappings&quot;, singleton methods that map directly to functions in GMP. These methods take return arguments, so that passing an object to a functional mapping may change the object itself. For example:</p>
 
 <pre><code>a = GMP::Z(0)
 b = GMP::Z(13)
@@ -396,7 +395,7 @@ GMP::Z.add(a, b, c)
 a  #=&gt; 30
 </code></pre>
 
-<p>Here's a fun list of all of the functional mappings written so far:</p>
+<p>Here&#39;s a fun list of all of the functional mappings written so far:</p>
 
 <pre><code>GMP::Z
   .abs          .add          .addmul       .cdiv_q_2exp  .cdiv_r_2exp  .com
@@ -415,7 +414,6 @@ a  #=&gt; 30
 <li><a href="https://github.com/srawlins/gmp/blob/master/CHANGELOG">CHANGELOG</a></li>
 </ul>
 
-
 <h2>Testing</h2>
 
 <p>Tests can be run with:</p>
@@ -424,21 +422,26 @@ a  #=&gt; 30
 ruby unit_tests.rb
 </code></pre>
 
-<p>If you have the unit_test gem installed, all tests should pass. Otherwise, one test may error. I imagine there is a bug in Ruby's built-in <code>Test::Unit</code> package that is fixed with the unit_test gem.</p>
+<p>If you have the unit_test gem installed, all tests should pass. Otherwise, one test may error. I imagine there is a bug in Ruby&#39;s built-in <code>Test::Unit</code> package that is fixed with the unit_test gem.</p>
+
+<p>You can also use the following shiny new rake tasks:</p>
+
+<pre><code>rake test
+rake report
+MPFR=no-mpfr rake report
+</code></pre>
 
 <h2>Known Issues</h2>
 
 <ul>
-<li>Don't call <code>GMP::RandState(:lc_2exp_size)</code>. Give a 2nd arg.</li>
-<li>Don't use multiple assignment (<code>a = b = GMP::Z(0)</code>) with functional mappings.</li>
-<li>JRuby has some interesting bugs and flickering tests. GMP::Z(GMP::GMP_NUMB_MAX) for example, blows up.</li>
-<li>MPFR 3.1.0 breaks some of the random tests. This is because of a known change in MPFR. I just need my tests to become aware of the change.</li>
+<li>Don&#39;t call <code>GMP::RandState(:lc_2exp_size)</code>. Give a 2nd arg.</li>
+<li>Don&#39;t use multiple assignment (<code>a = b = GMP::Z(0)</code>) with functional mappings.</li>
+<li>JRuby has some interesting bugs and flickering tests. GMP::Z(GMP::GMP<em>NUMB</em>MAX) for example, blows up.</li>
 </ul>
 
-
 <h2>Precision</h2>
 
-<p>Precision can be explicitely set as second argument for <code>GMP::F.new()</code>. If there is no explicit precision, highest precision of all <code>GMP::F</code> arguments is used. That doesn't ensure that result will be exact. For details, consult any paper about floating point arithmetics.</p>
+<p>Precision can be explicitely set as second argument for <code>GMP::F.new()</code>. If there is no explicit precision, highest precision of all <code>GMP::F</code> arguments is used. That doesn&#39;t ensure that result will be exact. For details, consult any paper about floating point arithmetics.</p>
 
 <p>Default precision can be explicitely set by passing <code>0</code> as the second argument for to <code>GMP::F.new()</code>. In particular, you can set precision of copy of <code>GMP::F</code> object by:</p>
 
@@ -449,63 +452,40 @@ ruby unit_tests.rb
 
 <h2>Benchmarking</h2>
 
-<p>"GMP is carefully designed to be as fast as possible." Therefore, I believe it is very important for GMP, and its various language bindings to be benchmarked. In recent years, the GMP team developed GMPbench, an elegant, weighted benchmark. Currently, they maintain a list of recent benchmark <a href="http://www.gmplib.org/gmpbench.html">results</a>, broken down by CPU, CPU freq, ABI, and compiler flags; GMPbench compares different processor's performance against eachother, rather than GMP against other bignum libraries, or comparing different versions of GMP.</p>
-
-<p>I intend to build a plug-in to GMPbench that will test the ruby gmp gem. The results of this benchmark should be directly comparable with the results of GMP (on same CPU, etc.). Rather than write a benchmark from the ground up, or try to emulate what GMPbench does, a plug-in will allow for this type of comparison. And in fact, GMPbench is (perhaps intentionally) written perfectly to allow for plugging in.</p>
-
-<p>Various scores are derived from GMPbench by running the <code>runbench</code> script. This script compiles and runs various individual programs that measure the performance of base functions, such as multiply, and app functions such as rsa.</p>
-
-<p>The gmp gem benchmark uses the GMPbench framework (that is, runbench, gexpr, and the timing methods), and plugs in ruby scripts as the individual programs. Right now, there are only four (of six) such plugged in ruby scripts:</p>
-
-<ul>
-<li>multiply - measures performance of multiplying (or squaring) <code>GMP::Z</code> objects whose size (in bits) is given by one or two operands.</li>
-<li>divide - measures performance of dividing two <code>GMP::Z</code> objects (using <code>tdiv</code>) whose size (in bits) is given by two operands.</li>
-<li>gcd - measure...</li>
-<li>rsa - measures performance of using RSA to sign messages. The size of <code>pq</code>, the product of the two co-prime <code>GMP::Z</code> objects, <code>p</code> and <code>q</code>, is given by one operand.</li>
-</ul>
-
-
-<p><strong>insert table here</strong></p>
-
-<p>My guess is that the increase in ruby gmp gem overhead is caused by increased efficiency in GMP; the inefficiencies of the gmp gem are relatively greater.</p>
+<p>Please see <a href="performance.md">performance</a></p>
 
 <h2>Todo</h2>
 
 <ul>
-<li><code>GMP::Z#to_d_2exp</code>, <code>#congruent?</code>, <code>#rootrem</code>, <code>#lcm</code>, <code>#kronecker</code>, <code>#bin</code>, <code>#fib2</code>, <code>#lucnum</code>, <code>#lucnum2</code>, <code>#hamdist</code>, <code>#combit</code>, <code>#fits_x?</code></li>
+<li><code>GMP::Z#to_d_2exp</code>, <code>#congruent?</code>, <code>#rootrem</code>, <code>#kronecker</code>, <code>#bin</code>, <code>#fib2</code>, <code>#lucnum</code>, <code>#lucnum2</code>, <code>#combit</code>, <code>#fits_x?</code></li>
 <li><code>GMP::Q#to_s(base)</code>, <code>GMP::F#to_s(base)</code> (test it!)</li>
-<li>benchmark gcdext, pi</li>
+<li>benchmark pi</li>
 <li>a butt-load of functional mappings. 47-ish sets.</li>
-<li>use Rake use Rake use Rake</li>
 <li>investigate possible memory leaks when using <code>GMP::Q(22/7)</code> for example</li>
-<li>beef up <code>r_gmpq_initialize</code>; I don't like to rely on <code>mpz_set_value</code>.</li>
+<li>beef up <code>r_gmpq_initialize</code>; I don&#39;t like to rely on <code>mpz_set_value</code>.</li>
 <li>finish compile-results.rb</li>
-<li>New in MPFR 3.1.0: mpfr_frexp, mpfr_grandom, mpfr_z_sub, divide-by-zero exception (?)</li>
+<li>New in MPFR 3.1.0: mpfr<em>frexp, mpfr</em>grandom, mpfr<em>z</em>sub, divide-by-zero exception (?)</li>
+<li>benchmark different orderings of type checks</li>
 </ul>
 
-
 <p>The below are inherited from Tomasz. I will go through these and see which are
 still relevant, and which I understand.</p>
 
 <ul>
 <li><code>mpz_fits_*</code> and 31 vs. 32 integer variables</li>
-<li>fix all sign issues (don't know what these are)</li>
+<li>fix all sign issues (don&#39;t know what these are)</li>
 <li><code>to_s</code> vs. <code>inspect</code></li>
 <li>check if <code>mpz_addmul_ui</code> would optimize some statements</li>
 <li>some system that allows using denref and numref as normal ruby objects</li>
 <li>takeover code that replaces all <code>Bignums</code> with <code>GMP::Z</code></li>
-<li>better bignum parser (how? <code>to_s</code> seems good to me.)</li>
+<li>better bignum parser (crawling into the Bignum extension)</li>
 <li>zero-copy method for strings generation</li>
 <li>benchmarks against Python GMP and Perl GMP</li>
-<li><code>dup</code> methods</li>
+<li><code>dup</code> methods for GMP::Q and GMP::F</li>
 <li>integrate <code>F</code> into system</li>
 <li>should <code>Z.\[\]</code> bits be 0/1 or true/false, 0 is true, which might surprise users</li>
 <li><code>any2small_integer()</code></li>
-<li>check asm output, especially local memory efficiency  (uh... no)</li>
-<li>it might be better to use 'register' for some local variables  (uh... no)</li>
 <li>powm with negative exponents</li>
-<li>check if different sorting of operatations gives better cache usage</li>
+<li>check if different sorting of operations gives better cache usage</li>
 <li><code>GMP::\*</code> op <code>RubyFloat</code> and <code>RubyFloat</code> op <code>GMP::\*</code></li>
-<li>sort checks</li>
 </ul>
-

data/README.markdown

@@ -230,6 +230,9 @@ Methods
       <=>,>=,>,<=,<            comparisions
     class methods of GMP::Z
       fac(n)                   factorial of n
+      2fac(n), double_fac(n)   double factorial of n
+      mfac(n)                  m-multi-factorial of n
+      primorial(n)             primorial of n
       fib(n)                   nth fibonacci number
       pow(n,m)                 n to mth power
     GMP::Z and GMP::Q
@@ -280,6 +283,7 @@ Methods
       legendre                 legendre symbol
       remove(n)                remove all occurences of factor n
       popcount                 the number of bits equal to 1
+      hamdist                  the hamming distance between two integers
       sizeinbase(b)            digits in base b
       size_in_bin              digits in binary
       size                     number of limbs
@@ -414,6 +418,12 @@ Tests can be run with:
 
 If you have the unit\_test gem installed, all tests should pass. Otherwise, one test may error. I imagine there is a bug in Ruby's built-in `Test::Unit` package that is fixed with the unit_test gem.
 
+You can also use the following shiny new rake tasks:
+
+    rake test
+    rake report
+    MPFR=no-mpfr rake report
+
 Known Issues
 ------------
 
@@ -440,7 +450,7 @@ Please see [performance](performance.md)
 Todo
 ----
 
-* `GMP::Z#to_d_2exp`, `#congruent?`, `#rootrem`, `#kronecker`, `#bin`, `#fib2`, `#lucnum`, `#lucnum2`, `#hamdist`, `#combit`, `#fits_x?`
+* `GMP::Z#to_d_2exp`, `#congruent?`, `#rootrem`, `#kronecker`, `#bin`, `#fib2`, `#lucnum`, `#lucnum2`, `#combit`, `#fits_x?`
 * `GMP::Q#to_s(base)`, `GMP::F#to_s(base)` (test it!)
 * benchmark pi
 * a butt-load of functional mappings. 47-ish sets.
@@ -448,6 +458,7 @@ Todo
 * beef up `r_gmpq_initialize`; I don't like to rely on `mpz_set_value`.
 * finish compile-results.rb
 * New in MPFR 3.1.0: mpfr_frexp, mpfr_grandom, mpfr_z_sub, divide-by-zero exception (?)
+* benchmark different orderings of type checks
 
 The below are inherited from Tomasz. I will go through these and see which are
 still relevant, and which I understand.
@@ -458,16 +469,13 @@ still relevant, and which I understand.
 * check if `mpz_addmul_ui` would optimize some statements
 * some system that allows using denref and numref as normal ruby objects
 * takeover code that replaces all `Bignums` with `GMP::Z`
-* better bignum parser (how? `to_s` seems good to me.)
+* better bignum parser (crawling into the Bignum extension)
 * zero-copy method for strings generation
 * benchmarks against Python GMP and Perl GMP
-* `dup` methods
+* `dup` methods for GMP::Q and GMP::F
 * integrate `F` into system
 * should `Z.\[\]` bits be 0/1 or true/false, 0 is true, which might surprise users
 * `any2small_integer()`
-* check asm output, especially local memory efficiency  (uh... no)
-* it might be better to use 'register' for some local variables  (uh... no)
 * powm with negative exponents
-* check if different sorting of operatations gives better cache usage
+* check if different sorting of operations gives better cache usage
 * `GMP::\*` op `RubyFloat` and `RubyFloat` op `GMP::\*`
-* sort checks

data/ext/gmpz.c

@@ -172,6 +172,39 @@ static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg)        \
   return res;                                                \
 }
 
+#define DEFUN_INT_SINGLETON_UIUI(fname,mpz_fname)                     \
+static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg1, VALUE arg2)    \
+{                                                                     \
+  MP_INT *arg1_val_z, *res_val;                                       \
+  unsigned long arg1_val_ul, arg2_val_ul;                             \
+  VALUE res;                                                          \
+                                                                      \
+  (void)klass;                                                        \
+                                                                      \
+  if (FIXNUM_P (arg1)) {                                              \
+    arg1_val_ul = FIX2NUM (arg1);                                     \
+  } else if (GMPZ_P (arg1)) {                                         \
+    mpz_get_struct (arg1, arg1_val_z);                                \
+    if (!mpz_fits_ulong_p (arg1_val_z))                               \
+      rb_raise (rb_eRangeError, "first argument out of range");       \
+    arg1_val_ul = mpz_get_ui (arg1_val_z);                            \
+    if (arg1_val_ul == 0)                                             \
+      rb_raise (rb_eRangeError, "first argument out of range");       \
+  } else {                                                            \
+    typeerror_as (ZX, "first argument");                              \
+  }                                                                   \
+                                                                      \
+  if (FIXNUM_P (arg2)) {                                              \
+    arg2_val_ul = FIX2NUM (arg2);                                     \
+  } else {                                                            \
+    typeerror_as (X, "second argument");                              \
+  }                                                                   \
+                                                                      \
+  mpz_make_struct_init (res, res_val);                                \
+  mpz_fname (res_val, arg1_val_ul, arg2_val_ul);                      \
+  return res;                                                         \
+}
+
 #define DEFUN_INT_COND_P(fname,mpz_fname)       \
 static VALUE r_gmpz_##fname(VALUE self)         \
 {                                               \
@@ -1968,7 +2001,7 @@ VALUE r_gmpz_jacobi(VALUE self, VALUE b)
 /*
  * call-seq:
  *   GMP::Z.jacobi(a, b)
- * 
+ *
  * Calculate the Jacobi symbol <i>(a/b)</i>. This is defined only for _b_ odd and
  * positive.
  */
@@ -1979,7 +2012,7 @@ VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b)
   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)) {
@@ -1992,7 +2025,7 @@ VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b)
   } else {
     typeerror_as(ZXB, "a");
   }
-  
+
   if (GMPZ_P(b)) {
     mpz_get_struct(b, b_val);
     if (mpz_sgn(b_val) != 1)
@@ -2021,7 +2054,7 @@ VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b)
   } 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); }
@@ -2115,6 +2148,80 @@ VALUE r_gmpz_remove(VALUE self, VALUE arg)
  * * GMP::Z.fac(4)  #=> 24
  */
 DEFUN_INT_SINGLETON_UI(fac, mpz_fac_ui)
+#if __GNU_MP_VERSION >= 5 && __GNU_MP_VERSION_MINOR >= 1  // 5.1.0 and newer
+
+/*
+ * Document-method: GMP::Z.2fac
+ *
+ * call-seq:
+ *   GMP::Z.send(:"2fac", n)
+ *   GMP::Z.double_fac(n)
+ *
+ * Returns <i>n!!</i>, the double factorial of _n_.
+ *
+ * Examples:
+ * * GMP::Z.double_fac(  0)  #=>    1
+ * * GMP::Z.double_fac(  1)  #=>    1
+ * * GMP::Z.double_fac(  2)  #=>    2
+ * * GMP::Z.double_fac(  3)  #=>    3
+ * * GMP::Z.double_fac(  4)  #=>    8
+ * * GMP::Z.double_fac(  5)  #=>   15
+ * * GMP::Z.double_fac(  6)  #=>   48
+ * * GMP::Z.double_fac(  7)  #=>  105
+ * * GMP::Z.double_fac(  8)  #=>  384
+ * * GMP::Z.double_fac(  9)  #=>  945
+ * * GMP::Z.double_fac( 10)  #=> 3840
+ * * GMP::Z.double_fac(100)
+ *     #=> 34243224702511976248246432895208185975118675053719198827915654463488000000000000
+ */
+DEFUN_INT_SINGLETON_UI(2fac,       mpz_2fac_ui)
+
+/*
+ * Document-method: GMP::Z.mfac
+ *
+ * call-seq:
+ *   GMP::Z.mfac(n)
+ *
+ * Returns <i>n!^(m)</i>, the m-multi-factorial of _n_.
+ *
+ * Examples:
+ * * GMP::Z.mfac(0,   3)  #=>    1
+ * * GMP::Z.mfac(1,   3)  #=>    1
+ * * GMP::Z.mfac(2,   3)  #=>    2
+ * * GMP::Z.mfac(3,   3)  #=>    3
+ * * GMP::Z.mfac(4,   3)  #=>    4
+ * * GMP::Z.mfac(5,   3)  #=>   10
+ * * GMP::Z.mfac(6,   3)  #=>   18
+ * * GMP::Z.mfac(7,   3)  #=>   28
+ * * GMP::Z.mfac(8,   3)  #=>   80
+ * * GMP::Z.mfac(9,   3)  #=>  162
+ * * GMP::Z.mfac(10,  3)  #=>  280
+ * * GMP::Z.mfac(11,  3)  #=>  880
+ * * GMP::Z.mfac(12,  3)  #=> 1944
+ */
+DEFUN_INT_SINGLETON_UIUI(mfac,     mpz_mfac_uiui)
+
+/*
+ * Document-method: GMP::Z.primorial
+ *
+ * call-seq:
+ *   GMP::Z.primorial(n)
+ *
+ * Returns the primorial _n_.
+ *
+ * Examples:
+ * * GMP::Z.primorial(0)  #=>   1
+ * * GMP::Z.primorial(1)  #=>   1
+ * * GMP::Z.primorial(2)  #=>   2
+ * * GMP::Z.primorial(3)  #=>   6
+ * * GMP::Z.primorial(4)  #=>   6
+ * * GMP::Z.primorial(5)  #=>  30
+ * * GMP::Z.primorial(6)  #=>  30
+ * * GMP::Z.primorial(7)  #=> 210
+ */
+DEFUN_INT_SINGLETON_UI(primorial,  mpz_primorial_ui)
+#endif
+
 /*
  * Document-method: GMP::Z.fib
  *
@@ -2132,7 +2239,8 @@ DEFUN_INT_SINGLETON_UI(fac, mpz_fac_ui)
  * * GMP::Z.fib(6)  #=>  8
  * * GMP::Z.fib(7)  #=> 13
  */
-DEFUN_INT_SINGLETON_UI(fib, mpz_fib_ui)
+DEFUN_INT_SINGLETON_UI(fib,    mpz_fib_ui)
+DEFUN_INT_SINGLETON_UI(lucnum, mpz_lucnum_ui)
 
 
 /**********************************************************************
@@ -2444,6 +2552,25 @@ VALUE r_gmpz_popcount(VALUE self)
   return INT2FIX(mpz_popcount(self_val));
 }
 
+/*
+ * call-seq:
+ *   a.hamdist(b)
+ *
+ * If _a_ and _b_ are both >= 0 or both < 0, calculate the hamming distance between _a_ and _b_. If one operand is >= 0 and the other is less than 0, then return "infinity" (the largest possible `mp_bitcnt_t`.
+ * positive.
+ */
+VALUE r_gmpz_hamdist(VALUE self_val, VALUE b_val)
+{
+  MP_INT *self, *b;
+  mpz_get_struct (self_val, self);
+  mpz_get_struct (   b_val,    b);
+  if (! GMPZ_P (b_val)) {
+    typeerror_as (Z, "b");
+  }
+
+  return INT2FIX (mpz_hamdist(self, b));
+}
+
 /*
  * call-seq:
  *   a.scan0(starting_bit)
@@ -2736,7 +2863,14 @@ void init_gmpz()
   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);
+#if __GNU_MP_VERSION >= 5 && __GNU_MP_VERSION_MINOR >= 1  // 5.1.0 and newer
+  rb_define_singleton_method(cGMP_Z, "2fac",          r_gmpzsg_2fac,      1);
+  rb_define_singleton_method(cGMP_Z, "double_fac",    r_gmpzsg_2fac,      1);
+  rb_define_singleton_method(cGMP_Z, "mfac",          r_gmpzsg_mfac,      2);
+  rb_define_singleton_method(cGMP_Z, "primorial",     r_gmpzsg_primorial, 1);
+#endif
   rb_define_singleton_method(cGMP_Z, "fib",           r_gmpzsg_fib,       1);
+  rb_define_singleton_method(cGMP_Z, "lucnum",        r_gmpzsg_lucnum,    1);
   // Functional Mappings
   rb_define_singleton_method(cGMP_Z, "lcm",           r_gmpzsg_lcm,       3);
   rb_define_singleton_method(cGMP_Z, "nextprime",     r_gmpzsg_nextprime, 2);
@@ -2755,16 +2889,17 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "hash",    r_gmpz_hash, 0);
 
   // Integer Logic and Bit Fiddling
-  rb_define_method(cGMP_Z, "&",        r_gmpz_and, 1);
-  rb_define_method(cGMP_Z, "|",        r_gmpz_or, 1);
-  rb_define_method(cGMP_Z, "^",        r_gmpz_xor, 1);
-  rb_define_method(cGMP_Z, "com",      r_gmpz_com, 0);
+  rb_define_method(cGMP_Z, "&",        r_gmpz_and,      1);
+  rb_define_method(cGMP_Z, "|",        r_gmpz_or,       1);
+  rb_define_method(cGMP_Z, "^",        r_gmpz_xor,      1);
+  rb_define_method(cGMP_Z, "com",      r_gmpz_com,      0);
   rb_define_method(cGMP_Z, "com!",     r_gmpz_com_self, 0);
   rb_define_method(cGMP_Z, "popcount", r_gmpz_popcount, 0);
-  rb_define_method(cGMP_Z, "scan0",    r_gmpz_scan0, 1);
-  rb_define_method(cGMP_Z, "scan1",    r_gmpz_scan1, 1);
-  rb_define_method(cGMP_Z, "[]=",      r_gmpz_setbit, 2);
-  rb_define_method(cGMP_Z, "[]",       r_gmpz_getbit, 1);
+  rb_define_method(cGMP_Z, "hamdist",  r_gmpz_hamdist,  1);
+  rb_define_method(cGMP_Z, "scan0",    r_gmpz_scan0,    1);
+  rb_define_method(cGMP_Z, "scan1",    r_gmpz_scan1,    1);
+  rb_define_method(cGMP_Z, "[]=",      r_gmpz_setbit,   2);
+  rb_define_method(cGMP_Z, "[]",       r_gmpz_getbit,   1);
   // Functional Mappings
   rb_define_singleton_method(cGMP_Z, "com", r_gmpzsg_com, 2);
 

data/ext/ruby_gmp.h

@@ -265,7 +265,11 @@ extern VALUE r_gmpf_set_prec_raw(VALUE self, VALUE arg);
 
 // Converting Floats
 extern VALUE r_gmpf_to_d(VALUE self);
+#ifdef MPFR
 extern VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self);
+#else
+extern VALUE r_gmpf_to_s(VALUE self);
+#endif
 
 // Float Arithmetic
 #ifndef MPFR

data/test/gmp_tprintf.rb

@@ -1,124 +1,126 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
 
-class GMP_TPRINTF < Test::Unit::TestCase
-  MAX_OUTPUT = 1024
-  def setup
-  end
+unless RUBY_VERSION =~ /^1.8/
+  class GMP_TPRINTF < Test::Unit::TestCase
+    MAX_OUTPUT = 1024
+    def setup
+    end
 
-  def check_plain(want, fmt_orig, *args)
-    fmt = ''
-    idx2 = 0
-    fmt_orig.split(//).each_with_index do |char, idx|
-      case char
-      # The exact value of the exponent isn't guaranteed in glibc, and it and
-      # gmp_printf do slightly different things, so don't compare directly.
-      when 'a' then return
-      when 'A' then return
-      when 'F'
-        if idx > 0 and fmt_orig[idx-1] == '.'
-          return  # don't test the "all digits" cases
+    def check_plain(want, fmt_orig, *args)
+      fmt = ''
+      idx2 = 0
+      fmt_orig.split(//).each_with_index do |char, idx|
+        case char
+        # The exact value of the exponent isn't guaranteed in glibc, and it and
+        # gmp_printf do slightly different things, so don't compare directly.
+        when 'a' then return
+        when 'A' then return
+        when 'F'
+          if idx > 0 and fmt_orig[idx-1] == '.'
+            return  # don't test the "all digits" cases
+          end
+          # discard 'F' type
+          next
+        when 'Z'
+          # transmute
+          # was 'l' in t-printf.c, but Ruby does not have such an 'l'
+          next
+        else
+          fmt[idx2] = fmt_orig[idx]
+          idx2 += 1
         end
-        # discard 'F' type
-        next
-      when 'Z'
-        # transmute
-        # was 'l' in t-printf.c, but Ruby does not have such an 'l'
-        next
-      else
-        fmt[idx2] = fmt_orig[idx]
-        idx2 += 1
       end
-    end
-    assert(fmt.size < MAX_OUTPUT)
-    got = GMP.sprintf(fmt, *args)
+      assert(fmt.size < MAX_OUTPUT)
+      got = GMP.sprintf(fmt, *args)
 
-    assert_equal(want, got, "GMP.sprintf() generates correct output.")
-  end
+      assert_equal(want, got, "GMP.sprintf() generates correct output.")
+    end
 
-  def check_one(want, fmt, *args)
-    assert_equal(want, GMP.sprintf(fmt, *args))
-  end
+    def check_one(want, fmt, *args)
+      assert_equal(want, GMP.sprintf(fmt, *args))
+    end
 
-  def hex_or_octal(fmt)
-    fmt =~ /[xXo]/
-  end
+    def hex_or_octal(fmt)
+      fmt =~ /[xXo]/
+    end
 
-  def test_check_z
-    data = [
-      ['%Zd',    '0',    '0'],
-      ['%Zd',    '1',    '1'],
-      ['%Zd',  '123',  '123'],
-      ['%Zd',   '-1',   '-1'],
-      ['%Zd', '-123', '-123'],
-
-      ['%+Zd',    '0',   '+0'],
-      ['%+Zd',  '123', '+123'],
-      ['%+Zd', '-123', '-123'],
-
-      ['%Zx',  '123',   '7b'],
-      ['%ZX',  '123',   '7B'],
-      ['%Zx', '-123',  '-7b'],
-      ['%ZX', '-123',  '-7B'],
-      ['%Zo',  '123',  '173'],
-      ['%Zo', '-123', '-173'],
-
-      ['%#Zx',    '0',     '0'],
-      ['%#ZX',    '0',     '0'],
-      ['%#Zx',  '123',  '0x7b'],
-      ['%#ZX',  '123',  '0X7B'],
-      ['%#Zx', '-123', '-0x7b'],
-      ['%#ZX', '-123', '-0X7B'],
-
-      ['%#Zo',    '0',     '0'],
-      ['%#Zo',  '123',  '0173'],
-      ['%#Zo', '-123', '-0173'],
-
-      ['%10Zd',    '0', '         0'],
-      ['%10Zd',  '123', '       123'],
-      ['%10Zd', '-123', '      -123'],
-
-      ['%-10Zd',    '0', '0         '],
-      ['%-10Zd',  '123', '123       '],
-      ['%-10Zd', '-123', '-123      '],
-
-      ['%+10Zd',   '123', '      +123'],
-      ['%+-10Zd',  '123', '+123      '],
-      ['%+10Zd',  '-123', '      -123'],
-      ['%+-10Zd', '-123', '-123      '],
-
-      ['%08Zd',    '0', '00000000'],
-      ['%08Zd',  '123', '00000123'],
-      ['%08Zd', '-123', '-0000123'],
-
-      ['%+08Zd',    '0', '+0000000'],
-      ['%+08Zd',  '123', '+0000123'],
-      ['%+08Zd', '-123', '-0000123'],
-
-      ['%#08Zx',    '0', '00000000'],
-      ['%#08Zx',  '123', '0x00007b'],
-      ['%#08Zx', '-123', '-0x0007b'],
-
-      ['%+#08Zx',    '0', '+0000000'],
-      ['%+#08Zx',  '123', '+0x0007b'],
-      ['%+#08Zx', '-123', '-0x0007b'],
-
-      ['%.0Zd', '0', ''],
-      ['%.1Zd', '0', '0'],
-      ['%.2Zd', '0', '00'],
-      ['%.3Zd', '0', '000']
-    ]
-
-    data.each do |parameters|
-      z = GMP::Z(parameters[1])
-      if not hex_or_octal(parameters[0]) and (parameters[0]['+'] or z < 0)
-        check_plain(parameters[2], parameters[0], z.to_i)
-      end
+    def test_check_z
+      data = [
+        ['%Zd',    '0',    '0'],
+        ['%Zd',    '1',    '1'],
+        ['%Zd',  '123',  '123'],
+        ['%Zd',   '-1',   '-1'],
+        ['%Zd', '-123', '-123'],
+
+        ['%+Zd',    '0',   '+0'],
+        ['%+Zd',  '123', '+123'],
+        ['%+Zd', '-123', '-123'],
+
+        ['%Zx',  '123',   '7b'],
+        ['%ZX',  '123',   '7B'],
+        ['%Zx', '-123',  '-7b'],
+        ['%ZX', '-123',  '-7B'],
+        ['%Zo',  '123',  '173'],
+        ['%Zo', '-123', '-173'],
+
+        ['%#Zx',    '0',     '0'],
+        ['%#ZX',    '0',     '0'],
+        ['%#Zx',  '123',  '0x7b'],
+        ['%#ZX',  '123',  '0X7B'],
+        ['%#Zx', '-123', '-0x7b'],
+        ['%#ZX', '-123', '-0X7B'],
+
+        ['%#Zo',    '0',     '0'],
+        ['%#Zo',  '123',  '0173'],
+        ['%#Zo', '-123', '-0173'],
+
+        ['%10Zd',    '0', '         0'],
+        ['%10Zd',  '123', '       123'],
+        ['%10Zd', '-123', '      -123'],
+
+        ['%-10Zd',    '0', '0         '],
+        ['%-10Zd',  '123', '123       '],
+        ['%-10Zd', '-123', '-123      '],
+
+        ['%+10Zd',   '123', '      +123'],
+        ['%+-10Zd',  '123', '+123      '],
+        ['%+10Zd',  '-123', '      -123'],
+        ['%+-10Zd', '-123', '-123      '],
+
+        ['%08Zd',    '0', '00000000'],
+        ['%08Zd',  '123', '00000123'],
+        ['%08Zd', '-123', '-0000123'],
+
+        ['%+08Zd',    '0', '+0000000'],
+        ['%+08Zd',  '123', '+0000123'],
+        ['%+08Zd', '-123', '-0000123'],
+
+        ['%#08Zx',    '0', '00000000'],
+        ['%#08Zx',  '123', '0x00007b'],
+        ['%#08Zx', '-123', '-0x0007b'],
+
+        ['%+#08Zx',    '0', '+0000000'],
+        ['%+#08Zx',  '123', '+0x0007b'],
+        ['%+#08Zx', '-123', '-0x0007b'],
+
+        ['%.0Zd', '0', ''],
+        ['%.1Zd', '0', '0'],
+        ['%.2Zd', '0', '00'],
+        ['%.3Zd', '0', '000']
+      ]
+
+      data.each do |parameters|
+        z = GMP::Z(parameters[1])
+        if not hex_or_octal(parameters[0]) and (parameters[0]['+'] or z < 0)
+          check_plain(parameters[2], parameters[0], z.to_i)
+        end
 
-      check_one(parameters[2], parameters[0], z)
+        check_one(parameters[2], parameters[0], z)
 
-      # Same again, with %N and possibly some high zero limbs
-      nfmt = parameters[0].dup
-      #lots more weird code... resulting in another check_one
+        # Same again, with %N and possibly some high zero limbs
+        nfmt = parameters[0].dup
+        #lots more weird code... resulting in another check_one
+      end
     end
   end
 end

data/test/tc_f_precision.rb

@@ -9,7 +9,7 @@ class TC_precision < Test::Unit::TestCase
       @initial_default_prec = GMP::F.default_prec
     end
   end
-  
+
   def test_initial_default_precision
     begin
       GMP::MPFR_VERSION
@@ -18,7 +18,7 @@ class TC_precision < Test::Unit::TestCase
       assert_equal(64, GMP::F.default_prec, "The initial default precision without MPFR should be 64.")
     end
   end
-  
+
   def test_initial_default_precision2
     @pi = GMP::F.new(3.14)
     @seven_halves = GMP::F.new(GMP::Q.new(7,2), 1000)
@@ -39,7 +39,7 @@ class TC_precision < Test::Unit::TestCase
     assert_in_delta(3.14000000000000012434, GMP::F.new(@pi),             1e-12)
     assert_equal(@initial_default_prec,        GMP::F.new(@pi).prec)
   end
-  
+
   def test_default_precision
     GMP::F.default_prec = 128
     @pi = GMP::F.new(3.14)
@@ -62,8 +62,9 @@ class TC_precision < Test::Unit::TestCase
     assert_equal(128, GMP::F.new(@pi).prec)
     GMP::F.default_prec =  @initial_default_prec
   end
-  
+
   def test_specific_precision
+    return if not GMP.const_defined? :MPFR_VERSION  # I think I can actually fix this...
     @pi = GMP::F.new(3.14)
     @seven_halves = GMP::F.new(GMP::Q.new(7,2), 1024)
     assert_equal(0, GMP::F.new(3.14, 1024).to_s =~ /0\.31400000000000001243449787580175325274467468261718750*e\+1/)
@@ -85,7 +86,7 @@ class TC_precision < Test::Unit::TestCase
     assert_in_delta(3.5, GMP::F.new(@seven_halves, 0), 1e-12)
     assert_equal(@initial_default_prec, GMP::F.new(@seven_halves, 0).prec)
   end
-  
+
   def test_set_default_prec
     begin
       GMP::MPFR_VERSION

data/test/tc_f_to_s.rb

@@ -10,6 +10,7 @@ class TC_F_to_s < Test::Unit::TestCase
   end
 
   def test_to_s_default_prec
+    return if not GMP.const_defined? :MPFR_VERSION  # I might be able to add this one back in...
     rs = GMP::RandState.new(11213)
     if GMP.const_defined? :MPFR_VERSION
       strings = [
@@ -37,6 +38,7 @@ class TC_F_to_s < Test::Unit::TestCase
   end
 
   def test_to_s_bigger_prec
+    return if not GMP.const_defined? :MPFR_VERSION
     rs  = GMP::RandState.new(19937)
     rs2 = GMP::RandState.new(21701)
     if GMP.const_defined? :MPFR_VERSION
@@ -57,6 +59,7 @@ class TC_F_to_s < Test::Unit::TestCase
   end
 
   def test_different_bases
+    return if not GMP.const_defined? :MPFR_VERSION
     f = GMP::F(0.5)
     assert_equal("0.50000000000000000e+0",                                     f.to_s)
     assert_equal("0.10000000000000000000000000000000000000000000000000000e+0", f.to_s(2))

data/test/tc_z_hamdist.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class TC_Z_Hamdist < Test::Unit::TestCase
+  def setup
+    @z32 = GMP::Z(32)  # 100000
+    @z33 = GMP::Z(33)  # 100001
+    @z34 = GMP::Z(34)  # 100010
+    @z35 = GMP::Z(35)  # 100011
+    @z36 = GMP::Z(36)  # 100100
+    @z37 = GMP::Z(37)  # 100101
+    @z38 = GMP::Z(38)  # 100110
+    @z39 = GMP::Z(39)  # 100111
+  end
+
+  def test_hamdist
+    assert_equal(0, @z32.hamdist(@z32), "GMP::Z should hamdist(GMP::Z:positive) correctly")
+    assert_equal(1, @z32.hamdist(@z33), "GMP::Z should hamdist(GMP::Z:positive) correctly")
+    assert_equal(1, @z32.hamdist(@z34), "GMP::Z should hamdist(GMP::Z:positive) correctly")
+    assert_equal(2, @z32.hamdist(@z35), "GMP::Z should hamdist(GMP::Z:positive) correctly")
+    assert_equal(1, @z32.hamdist(@z36), "GMP::Z should hamdist(GMP::Z:positive) correctly")
+    assert_equal(2, @z32.hamdist(@z37), "GMP::Z should hamdist(GMP::Z:positive) correctly")
+    assert_equal(2, @z32.hamdist(@z38), "GMP::Z should hamdist(GMP::Z:positive) correctly")
+    assert_equal(3, @z32.hamdist(@z39), "GMP::Z should hamdist(GMP::Z:positive) correctly")
+  end
+end

data/test/unit_tests.rb

@@ -13,6 +13,7 @@ require './tc_z_addmul'
 require './tc_z_submul'
 require './tc_z_logic'
 require './tc_z_exponentiation'
+require './tc_z_hamdist'
 require './tc_z_to_dis'
 require './tc_z_shifts_last_bits'
 require './tc_z_jac_leg_rem'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gmp
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.6.13
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-12-09 00:00:00.000000000 Z
+date: 2012-12-12 00:00:00.000000000 Z
 dependencies: []
 description: gmp - providing Ruby bindings to the GMP library.
 email:
@@ -70,6 +70,7 @@ files:
 - test/tc_z_exponentiation.rb
 - test/tc_z_functional_mappings.rb
 - test/tc_z_gcd_lcm_invert.rb
+- test/tc_z_hamdist.rb
 - test/tc_z_jac_leg_rem.rb
 - test/tc_z_logic.rb
 - test/tc_z_shifts_last_bits.rb