gmp 0.6.31 → 0.6.41

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8f050d69659030fb11abceaf21d1ad265ac6d696
+  data.tar.gz: e15d7ae348a201bb6f5d53754141939128fa96ac
+SHA512:
+  metadata.gz: 10b8ea24e97956f68d0315211113c2b93642c16aaeb40ff767c45d5137a79b252ae2d94b5136ba4e230de2a5cf4aa3ff3f308ab51b5f8f2dc9a22d932eaa5d56
+  data.tar.gz: 55ebb541e81d2045a300006adc26926c8483ff3947618b21478abdba52c66eef89f0bf86e69fe2b6547427010ff60d1bab471d06ae1746bceff7041687873684

data/CHANGELOG

@@ -1,3 +1,14 @@
+0.6.41
+  * Added GMP::Z.fib2, with documentation and tests
+  * Properly coerce GMP::Q and Float. GMP::Q / Float will now convert both
+    operands into GMP::F
+  * Workaround Ruby 2.0.0 bug in using --with-gmp-dir in extconf.rb (#8047)
+  * Fixed bugs for Z#fac, Z#2fac, Z#primorial, Z#fib, and Z#lucnum, where Ruby
+    would crash if a negative number was passed in as the argument.
+  * Aliasing #inspect to #to_s for GMP::Z, GMP::Q, and GMP::F, for better
+    usability in Ruby 2.x, where Object#inspect no longer calls #to_s.
+  * Support now verified for Ruby 2.0.0 and Ruby 2.1.0-preview1
+
 0.6.31:
   * Added GMP::Z#rootrem and tests
 

data/FEATURES.html

@@ -106,8 +106,8 @@ Ext.onReady(function(){
         ['GMP::Z#remove',                   "mpz_remove",                              "yes","yes",   "", "no"],
         ['GMP::Z.fac',                      "mpz_fac_ui",                              "yes","yes",   "", "no"],
         ['',                                "mpz_bin_ui<br />mpz_bin_uiui",             "no", "no", "no", "no"],
-        ['GMP::Z.fib',                      "mpz_fib_ui",                              "yes","yes",   "", "no"],
-        ['',                                "mpz_fib2_ui",                              "no", "no", "no", "no"],
+        ['GMP::Z.fib',                      "mpz_fib_ui",                              "yes","yes","yes", "no"],
+        ['GMP::Z.fib2',                     "mpz_fib2_ui",                             "yes","yes","yes", "no"],
         ['',                                "mpz_lucnum_ui",                            "no", "no", "no", "no"],
         ['',                                "mpz_lucnum2_ui",                           "no", "no", "no", "no"],
         ['GMP::Z#==<br />GMP::Z#<=><br />' +
@@ -200,8 +200,8 @@ Ext.onReady(function(){
         ['GMP::Z#remove',                   "mpz_remove",                              "yes","yes",   "", "no"],
         ['GMP::Z.fac',                      "mpz_fac_ui",                              "yes","yes",   "", "no"],
         ['',                                "mpz_bin_ui<br />mpz_bin_uiui",             "no", "no", "no", "no"],
-        ['GMP::Z.fib',                      "mpz_fib_ui",                              "yes","yes",   "", "no"],
-        ['',                                "mpz_fib2_ui",                              "no", "no", "no", "no"],
+        ['GMP::Z.fib',                      "mpz_fib_ui",                              "yes","yes","yes", "no"],
+        ['GMP::Z.fib2',                     "mpz_fib2_ui",                             "yes","yes","yes", "no"],
         ['',                                "mpz_lucnum_ui",                            "no", "no", "no", "no"],
         ['',                                "mpz_lucnum2_ui",                           "no", "no", "no", "no"],
         ['GMP::Z#==<br />GMP::Z#<=><br />' +

data/README.markdown

@@ -47,8 +47,15 @@ paragraph at [their homepage](http://gmplib.org/#WHAT):
 > 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."
 
-Only GMP 4 or newer is supported. The following environments have been tested
-by me: gmp gem 0.5.47 on:
+GMP 4.3.x and GMP 5.x are each supported against Ruby (MRI) 1.9.x, 2.0.0, and
+2.1.0. GMP 5.1.x is the only version of GMP that has been tested recently.
+Other Ruby platforms (such as Rubinius and JRuby) should be supported, but have not
+been tested recently.
+
+### Previously
+
+Previously, on version 0.5.47, this gem was verified as functioning in the
+following combinations:
 
 <table border="1">
   <tr>
@@ -217,14 +224,16 @@ Methods
       -                        substraction
       *                        multiplication
       /                        division
-      to_s                     convert to string. For GMP::Z, this method takes
-                               one optional argument, a base. The base can be a
-                               Fixnum in the ranges \[2, 62\] or \[-36, -2\] or a
-                               Symbol: :bin, :oct, :dec, or :hex.
+      to_s                     convert to string. For GMP::Z and GMP::F, this
+                               method takes one optional argument, a base. The
+                               base can be a Fixnum in the ranges \[2, 62\] or
+                               \[-36, -2\] or a Symbol: one of :bin, :oct,
+                               :dec, or :hex.
+      inspect                  alias for #to_s
       -@                       negation
       neg!                     in-place negation
       abs                      absolute value
-      asb!                     in-place absolute value
+      abs!                     in-place absolute value
       coerce                   promotion of arguments
       ==                       equality test
       <=>,>=,>,<=,<            comparisions
@@ -233,7 +242,8 @@ Methods
       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
+      fib(n)                   nth Fibonacci number
+      fib2(n)                  nth and (n-1)th Fibonacci numbers
       pow(n,m)                 n to mth power
     GMP::Z and GMP::Q
       swap                     efficiently swap contents of two objects, there
@@ -406,6 +416,122 @@ Here's a fun list of all of the functional mappings written so far:
       .neg          .nextprime    .sqrt         .sub          .submul       .tdiv_q_2exp
       .tdiv_r_2exp
 
+Method Tables
+-------------
+
+The following is organized in the same categories as in the GMP and MPFR manuals.
+
+### Integer Functions
+
+<table>
+  <tr><th colspan="2"><h4>Assigning Integers</h4></th></tr>
+  <tr><th>GMP Function</th><th>GMP::Z method</th></tr>
+  <tr><td>mpz_swap</td><td>GMP::Z#swap</td></tr>
+
+  <tr><th colspan="2"><h4>Converting Integers</h4>
+                      4x C functions mapped to 3x Ruby methods; 1x unmapped C function</th></tr>
+  <tr><th>GMP Function</th><th>GMP::Z method</th></tr>
+  <tr><td>mpz_get_ui<br />
+          mpz_get_si</td>      <td>GMP::Z#to_i</td></tr>
+  <tr><td>mpz_get_d</td>       <td>GMP::Z#to_d</td></tr>
+  <tr><td>mpz_get_d_2exp</td>  <td><em>not implemented yet</em></td></tr>
+  <tr><td>mpz_get_str</td>     <td>GMP::Z#to_s</td></tr>
+
+  <tr><th colspan="2"><h4>Integer Arithmetic</h4>
+                      12x C functions mapped to 19x Ruby methods; 2x unmapped C functions</th></tr>
+  <tr><th>GMP Function</th><th>GMP::Z method</th></tr>
+  <tr><td>mpz_add<br />
+          mpz_add_ui</td>               <td>GMP::Z#+<br />
+                                            GMP::Z#add! (destructive method)<br />
+                                            GMP::Z.add (in-place singleton method)</td></tr>
+  <tr><td>mpz_sub<br />
+          mpz_sub_ui<br />
+          mpz_ui_sub (never used)</td>  <td>GMP::Z#-<br />
+                                            GMP::Z#sub! (destructive method)<br />
+                                            GMP::Z.sub (in-place singleton method)</td></tr>
+  <tr><td>mpz_mul<br />
+          mpz_mul_si<br />
+          mpz_mul_ui (not used yet)</td><td>GMP::Z#*<br />
+                                            GMP::Z.mul (in-place singleton method)</td></tr>
+  <tr><td>mpz_addmul<br />
+          mpz_addmul_ui</td>            <td>GMP::Z#addmul! (destructive method)<br />
+                                            GMP::Z.addmul (in-place singleton method)</td></tr>
+  <tr><td>mpz_submul<br />
+          mpz_submul_ui</td>            <td>GMP::Z#submul! (destructive method)<br />
+                                            GMP::Z.submul (in-place singleton method)</td></tr>
+  <tr><td>mpz_mul_2exp</td>             <td>GMP::Z.mul_2exp (in-place singleton method)</td></tr>
+  <tr><td>mpz_neg</td>                  <td>GMP::Z@-<br />
+                                            GMP::Z#neg! (destructive method)<br />
+                                            GMP::Z.neg (in-place singleton method)</td></tr>
+  <tr><td>mpz_abs</td>                  <td>GMP::Z#abs<br />
+                                            GMP::Z#abs! (destructive method)<br />
+                                            GMP::Z.abs (in-place singleton method)</td></tr>
+
+  <tr><th colspan="2"><h4>Integer Division</h4>
+                      26x C functions mapped to 18x Ruby methods; 11x unmapped C functions</th></tr>
+  <tr><th>GMP Function</th><th>GMP::Z method</th></tr>
+  <tr><td>mpz_cdiv_q<br />
+          mpz_cdiv_q_ui</td>            <td>GMP::Z#cdiv</td></tr>
+  <tr><td>mpz_cdiv_r<br />
+          mpz_cdiv_r_ui</td>            <td>GMP::Z#cmod</td></tr>
+  <tr><td>mpz_cdiv_qr<br />
+          mpz_cdiv_qr_ui</td>           <td><em>not implemented yet</em></td></tr>
+  <tr><td>mpz_cdiv_ui</td>              <td><em>not implemented yet</em></td></tr>
+  <tr><td>mpz_cdiv_q_2exp<br />
+          mpz_cdiv_r_2exp</td>          <td>GMP::Z.cdiv_q_2exp (in-place singleton method)<br />
+                                            GMP::Z.cdiv_r_2exp (in-place singleton method)</td></tr>
+  <tr><td>mpz_fdiv_q<br />
+          mpz_fdiv_q_ui</td>            <td>GMP::Z#fdiv</td></tr>
+  <tr><td>mpz_fdiv_r<br />
+          mpz_fdiv_r_ui</td>            <td>GMP::Z#fmod</td></tr>
+  <tr><td>mpz_fdiv_qr<br />
+          mpz_fdiv_qr_ui</td>           <td><em>not implemented yet</em></td></tr>
+  <tr><td>mpz_fdiv_ui</td>              <td><em>not implemented yet</em></td></tr>
+  <tr><td>mpz_fdiv_q_2exp<br />
+          mpz_fdiv_r_2exp</td>          <td>GMP::Z.fdiv_q_2exp (in-place singleton method)<br />
+                                            GMP::Z.fdiv_r_2exp (in-place singleton method)</td></tr>
+  <tr><td>mpz_tdiv_q<br />
+          mpz_tdiv_q_ui</td>            <td>GMP::Z#tdiv</td></tr>
+  <tr><td>mpz_tdiv_r<br />
+          mpz_tdiv_r_ui</td>            <td>GMP::Z#tmod</td></tr>
+  <tr><td>mpz_tdiv_qr<br />
+          mpz_tdiv_qr_ui</td>           <td><em>not implemented yet</em></td></tr>
+  <tr><td>mpz_tdiv_ui</td>              <td><em>not implemented yet</em></td></tr>
+  <tr><td>mpz_tdiv_q_2exp<br />
+          mpz_tdiv_r_2exp</td>          <td>GMP::Z.tdiv_q_2exp (in-place singleton method)<br />
+                                            GMP::Z.tdiv_r_2exp (in-place singleton method)</td></tr>
+  <tr><td>mpz_mod<br />
+          mpz_mod_ui</td>               <td>GMP::Z#mod</td></tr>
+  <tr><td>mpz_divexact<br />
+          mpz_divexact_ui</td>          <td>GMP::Z.divexact (in-place singleton method)</td></tr>
+  <tr><td>mpz_divisible_p<br />
+          mpz_divisible_ui_p</td>       <td>GMP::Z#divisible?<br />
+                                            GMP::Z.divisible? (in-place singleton method)</td></tr>
+  <tr><td>mpz_divisible_2exp_p</td>     <td><em>not implemented yet</em></td></tr>
+  <tr><td>mpz_congruent_p<br />
+          mpz_congruent_ui_p</td>       <td>GMP::Z#congruent?<br />
+                                            GMP::Z.congruent? (in-place singleton method)</td></tr>
+  <tr><td>mpz_congruent_2exp_p</td>     <td><em>not implemented yet</em></td></tr>
+
+  <tr><th colspan="2"><h4>Integer Exponentiation</h4>
+
+  <tr><th colspan="2"><h4>Integer Roots</h4>
+
+  <tr><th colspan="2"><h4>Number Theoretic Functions</h4>
+
+  <tr><th colspan="2"><h4>Integer Comparisons</h4>
+
+  <tr><th colspan="2"><h4>Integer Logic and Bit Fiddling</h4>
+
+  <tr><th colspan="2"><h4>I/O of Integers</h4>
+
+  <tr><th colspan="2"><h4>Integer Random Numbers</h4>
+
+  <tr><th colspan="2"><h4>Integer Import and Export</h4>
+
+  <tr><th colspan="2"><h4>Miscellaneous Integer Functions</h4>
+</table>
+
 Documentation
 -------------
 
@@ -417,18 +543,12 @@ Documentation
 Testing
 -------
 
-Tests can be run with:
-
-    cd test
-    ruby unit_tests.rb
+Tests can be run with `rake test`. I like to run tests and print out a quick report of Ruby, GMP, and MPFR versions with `rake report`. You can precede any rake task with `GMP=gmp_install_dir` and `MPFR=mpfr_install_dir` (or `MPFR=--no-mpfr`) to pass `--with-gmp-dir` and `--with-mpfr-dir` options to `extconf.rb` as well.
 
-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 run tests from an individual file with:
 
-You can also use the following shiny new rake tasks:
-
-    rake test
-    rake report
-    MPFR=no-mpfr rake report
+    cd test
+    ruby some_test_file.rb
 
 Known Issues
 ------------
@@ -469,13 +589,14 @@ Please see [performance](https://github.com/srawlins/gmp/blob/master/performance
 Todo
 ----
 
-* `GMP::Z#to_d_2exp`, `#kronecker`, `#bin`, `#fib2`, `#lucnum`, `#lucnum2`, `#combit`, `#fits_x?`
+* `GMP::Z#to_d_2exp`, `#kronecker`, `#bin`, `::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.
 * investigate possible memory leaks when using `GMP::Q(22/7)` for example
 * beef up `r_gmpq_initialize`; I don't like to rely on `mpz_set_value`.
 * finish compile-results.rb
+* check if `mpz_mul_ui` would optimize `GMP::Z#*`
 * New in MPFR 3.1.0: mpfr_frexp, mpfr_grandom, mpfr_z_sub, divide-by-zero exception (?)
 * JRuby doesn't like some MPFR stuff, specifically sqrt tests fail.
 * Rubinius in 1.9 mode fails a sprintf test in a minor way.
@@ -484,7 +605,6 @@ The below are inherited from Tomasz. I will go through these and see which are
 still relevant, and which I understand.
 
 * `mpz_fits_*` and 31 vs. 32 integer variables
-* fix all sign issues (don't know what these are)
 * 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`

data/benchmark/bench.sh

@@ -0,0 +1,32 @@
+#! /bin/bash
+source ~/.rvm/scripts/rvm
+
+function out {
+  echo "========================================"
+  echo "$*"
+  echo "========================================"
+}
+
+echo "RUBY:   `ruby -v`"
+echo "GMP:    `ruby -r '../ext/gmp' -e \"puts GMP::GMP_VERSION\"`"
+echo "GMP_CC: `ruby -r '../ext/gmp' -e \"puts GMP::GMP_CC\"`"
+echo "MPFR:   `ruby -r '../ext/gmp' -e \"puts GMP::MPFR_VERSION\"`"
+
+if [[ $1 == --help ]]; then
+  echo "bench.sh benchmark_directory ..."
+  exit 1
+fi
+
+ruby_version=`ruby -v |cut -d' ' -f 2`
+PATH=.:$PATH
+for directory in "$@"; do
+  out "Benchmarking in $directory..."
+  cd $directory
+  if [ ! -f runbench ]; then
+    echo "Oops, not a benchmark directory! 'runbench' does not exist."
+  else
+    echo "./runbench -n |tee ${ruby_version}.txt"
+    ./runbench -n |tee ${ruby_version}.txt
+    cd -
+  fi
+done

data/benchmark/csv.sh

@@ -0,0 +1 @@
+sed 's/[ ]*GMPbench:[ ]*//' |sed 's/[ ]*GMPbench.[a-z]*.[a-z]*([0-9,]*)[ ]*/,,,/' |sed 's/[ ]*GMPbench.[a-z]*\.[a-z]*[ ]*/,,/' |sed 's/[ ]*GMPbench.[a-z]*[ ]*/,/' |sed 's/Program.*//' |sed 's/Category.*//'

data/ext/extconf.rb

@@ -2,6 +2,10 @@
 
 require 'mkmf'
 
+# Workaround for Ruby bug #8074, introduced in Ruby 2.0.0, fixed in Ruby 2.1.0
+# https://bugs.ruby-lang.org/issues/8074
+@libdir_basename = "lib"
+
 dir_config('gmp')
 dir_config('mpfr')
 

data/ext/gmp.c

@@ -27,7 +27,10 @@ static VALUE r_gmpz_coerce(VALUE self, VALUE arg)
 
 static VALUE r_gmpq_coerce(VALUE self, VALUE arg)
 {
-  return rb_assoc_new(r_gmpqsg_new(1, &arg, cGMP_Q), self);
+  if (FLOAT_P(arg))
+    return rb_assoc_new(r_gmpfsg_new(1, &arg, cGMP_F), r_gmpfsg_new(1, &self, cGMP_F));
+  else
+    return rb_assoc_new(r_gmpqsg_new(1, &arg, cGMP_Q), self);
 }
 
 static VALUE r_gmpf_coerce(VALUE self, VALUE arg)
@@ -55,6 +58,34 @@ static VALUE r_gmpfsg_set_default_prec(VALUE klass, VALUE arg)
   return Qnil;
 }
 
+ID bin_base_id;                                             /* binary */
+ID oct_base_id;                                              /* octal */
+ID dec_base_id;                                            /* decimal */
+ID hex_base_id;                                        /* hexadecimal */
+
+int get_base(VALUE base_val) {
+  ID base_id;
+  int base = 10;
+
+  if (FIXNUM_P(base_val)) {
+    base = FIX2INT(base_val);
+
+    if ((base >= 2 && base <= 62) || (base >= -36 && base <= -2))
+      return base;
+    else
+      rb_raise(rb_eRangeError, "base must be within [2, 62] or [-36, -2].");
+  } else if (SYMBOL_P(base_val)) {
+    base_id = rb_to_id(base_val);
+    if (base_id == bin_base_id) return 2;
+    else if (base_id == oct_base_id) return 8;
+    else if (base_id == dec_base_id) return 10;
+    else if (base_id == hex_base_id) return 16;
+    else rb_raise(rb_eRangeError, "base must be within [2, 62] or [-36, -2].");
+  } else {
+    rb_raise(rb_eTypeError, "Expected Fixnum or one of :bin, :oct, :dec, :hex");
+  }
+}
+
 VALUE r_gmpsg_sprintf2(VALUE klass, VALUE format, VALUE arg) {
   VALUE res;
   char *buffer;
@@ -128,6 +159,11 @@ mp_rnd_t r_get_rounding_mode(VALUE rnd)
   rb_define_method(rb_cBignum, ruby_fname, takeover_bignum_##fname, -1);
 
 void Init_gmp() {
+  bin_base_id = rb_intern("bin");
+  oct_base_id = rb_intern("oct");
+  dec_base_id = rb_intern("dec");
+  hex_base_id = rb_intern("hex");
+
   mGMP = rb_define_module("GMP");
   rb_define_const(mGMP, "GMP_VERSION",       rb_str_new2(gmp_version));
   rb_define_const(mGMP, "GMP_CC",            rb_str_new2(__GMP_CC));

data/ext/gmpf.c

@@ -136,6 +136,8 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
   }
 
 #else
+  (void)base;
+
   if (prec == 0)
     r_mpf_init (self_val);
   else
@@ -266,54 +268,17 @@ VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self)
   char *str, *str2;
   VALUE res;
   mp_exp_t exponent;
-
-  VALUE base;
-  int base_val = 10;
-  ID base_id;
-  const char * bin_base = "bin";                            /* binary */
-  const char * oct_base = "oct";                             /* octal */
-  const char * dec_base = "dec";                           /* decimal */
-  const char * hex_base = "hex";                       /* hexadecimal */
-  ID bin_base_id = rb_intern(bin_base);
-  ID oct_base_id = rb_intern(oct_base);
-  ID dec_base_id = rb_intern(dec_base);
-  ID hex_base_id = rb_intern(hex_base);
+  VALUE base_val;
+  int base = 10;
 
   mpf_get_struct(self, self_val);
 
   /* TODO: accept a second optional argument, n_digits */
-  rb_scan_args (argc, argv, "01", &base);
-
-  /* The entire following stanza is determining the base. */
-  if (NIL_P (base)) { base = INT2FIX (10); }           /* default value */
-  if (FIXNUM_P (base)) {
-    base_val = FIX2INT (base);
-    if ((base_val >=   2 && base_val <= 62) ||
-        (base_val >= -36 && base_val <= -2)) {
-      /* good base */
-    } else {
-      base_val = 10;
-      rb_raise (rb_eRangeError, "base must be within [2, 62] or [-36, -2].");
-    }
-  } else if (SYMBOL_P (base)) {
-    base_id = rb_to_id (base);
-    if (base_id == bin_base_id) {
-      base_val =  2;
-    } else if (base_id == oct_base_id) {
-      base_val =  8;
-    } else if (base_id == dec_base_id) {
-      base_val = 10;
-    } else if (base_id == hex_base_id) {
-      base_val = 16;
-    } else {
-      base_val = 10;  /* TODO: should raise an exception here. */
-    }
-  }
+  rb_scan_args(argc, argv, "01", &base_val);
+  if (NIL_P(base_val)) { base = 10; }                /* default value */
+  else { base = get_base(base_val); }
 
-  //mpfr_sprintf(str, "%Rf", self_val);
-  //res = rb_str_new2(str);
-
-  str = mpfr_get_str(NULL, &exponent, base_val, 0, self_val, __gmp_default_rounding_mode);
+  str = mpfr_get_str(NULL, &exponent, base, 0, self_val, __gmp_default_rounding_mode);
   if ((strcmp(str,  "NaN") == 0) ||
       (strcmp(str,  "Inf") == 0) ||
       (strcmp(str, "-Inf") == 0))
@@ -326,6 +291,7 @@ VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self)
       __gmp_asprintf(&str2, "-0.%se%+ld", str+1, exponent);
     else
       __gmp_asprintf(&str2, "0.%se%+ld", str, exponent);
+
     res = rb_str_new2(str2);
     mpfr_free_str(str2);
   }
@@ -1288,6 +1254,7 @@ void init_gmpf()
 
   // Converting Floats
   rb_define_method(cGMP_F, "to_s", r_gmpf_to_s, -1);
+  rb_define_alias(cGMP_F, "inspect", "to_s");
   rb_define_method(cGMP_F, "to_d",  r_gmpf_to_d, 0);
   rb_define_alias(cGMP_F, "to_f", "to_d");
 

data/ext/gmpq.c

@@ -807,12 +807,13 @@ void init_gmpq()
   // Initializing Rationals
   rb_define_singleton_method(cGMP_Q, "new", r_gmpqsg_new, -1);
   rb_define_method(cGMP_Q, "swap",  r_gmpq_swap, 1);
-  
+
   // Rational Conversions
   rb_define_method(cGMP_Q, "to_d", r_gmpq_to_d, 0);
   rb_define_alias(cGMP_Q, "to_f", "to_d");
   rb_define_method(cGMP_Q, "to_s", r_gmpq_to_s, 0);
-  
+  rb_define_alias(cGMP_Q, "inspect", "to_s");
+
   // Rational Arithmetic
   rb_define_method(cGMP_Q, "+",    r_gmpq_add, 1);
   rb_define_method(cGMP_Q, "-",    r_gmpq_sub, 1);

data/ext/gmpz.c

@@ -154,7 +154,7 @@ static VALUE r_gmpz_##fname(VALUE self, VALUE arg) \
 static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg)        \
 {                                                            \
   MP_INT *arg_val_z, *res_val;                               \
-  unsigned long arg_val_ul;                                  \
+  long arg_val_ul;                                           \
   VALUE res;                                                 \
                                                              \
   (void)klass;                                               \
@@ -165,17 +165,50 @@ static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg)        \
     mpz_get_struct (arg, arg_val_z);                         \
     if (!mpz_fits_ulong_p (arg_val_z))                       \
       rb_raise (rb_eRangeError, "argument out of range");    \
-    arg_val_ul = mpz_get_ui (arg_val_z);                     \
-    if (arg_val_ul == 0)                                     \
-      rb_raise (rb_eRangeError, "argument out of range");    \
+    arg_val_ul = mpz_get_si (arg_val_z);                     \
   } else {                                                   \
     typeerror_as (ZX, "argument");                           \
   }                                                          \
+                                                             \
+  if (arg_val_ul < 0)                                        \
+    rb_raise (rb_eRangeError, "argument out of range");      \
+                                                             \
   mpz_make_struct_init (res, res_val);                       \
-  mpz_fname (res_val, arg_val_ul);                           \
+  mpz_fname (res_val, (unsigned long)arg_val_ul);            \
+                                                             \
   return res;                                                \
 }
 
+#define DEFUN_INT_SINGLETON_ZZ_UI(fname,mpz_fname)              \
+static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg)           \
+{                                                               \
+  MP_INT *arg_val_z, *res_val_1, *res_val_2;                    \
+  long arg_val_ul;                                              \
+  VALUE res_1, res_2;                                           \
+                                                                \
+  (void)klass;                                                  \
+                                                                \
+  if (FIXNUM_P (arg)) {                                         \
+    arg_val_ul = FIX2NUM (arg);                                 \
+  } else if (GMPZ_P (arg)) {                                    \
+    mpz_get_struct (arg, arg_val_z);                            \
+    if (!mpz_fits_ulong_p (arg_val_z))                          \
+      rb_raise (rb_eRangeError, "argument out of range");       \
+    arg_val_ul = mpz_get_si (arg_val_z);                        \
+  } else {                                                      \
+    typeerror_as (ZX, "argument");                              \
+  }                                                             \
+                                                                \
+  if (arg_val_ul < 0)                                           \
+    rb_raise (rb_eRangeError, "argument out of range");         \
+                                                                \
+  mpz_make_struct_init (res_1, res_val_1);                      \
+  mpz_make_struct_init (res_2, res_val_2);                      \
+  mpz_fname (res_val_1, res_val_2, (unsigned long)arg_val_ul);  \
+                                                                \
+  return rb_assoc_new(res_1, res_2);                            \
+}
+
 #define DEFUN_INT_SINGLETON_UIUI(fname,mpz_fname)                     \
 static VALUE r_gmpzsg_##fname(VALUE klass, VALUE arg1, VALUE arg2)    \
 {                                                                     \
@@ -851,51 +884,20 @@ VALUE r_gmpz_to_d(VALUE self)
  * digits and upper-case letters are used; for 37..62, digits, upper-case letters, and
  * lower-case letters (in that significance order) are used.
  */
-VALUE r_gmpz_to_s(int argc, VALUE *argv, VALUE self)
+VALUE r_gmpz_to_s(int argc, VALUE *argv, VALUE self_val)
 {
-  MP_INT *self_val;
+  MP_INT *self;
   char *str;
   VALUE res;
-  VALUE base;
-  int base_val = 10;
-  ID base_id;
-  const char * bin_base = "bin";                            /* binary */
-  const char * oct_base = "oct";                             /* octal */
-  const char * dec_base = "dec";                           /* decimal */
-  const char * hex_base = "hex";                       /* hexadecimal */
-  ID bin_base_id = rb_intern(bin_base);
-  ID oct_base_id = rb_intern(oct_base);
-  ID dec_base_id = rb_intern(dec_base);
-  ID hex_base_id = rb_intern(hex_base);
-
-  rb_scan_args(argc, argv, "01", &base);
-  if (NIL_P(base)) { base = INT2FIX(10); }           /* default value */
-  if (FIXNUM_P(base)) {
-    base_val = FIX2INT(base);
-    if ((base_val >=   2 && base_val <= 62) ||
-        (base_val >= -36 && base_val <= -2)) {
-      /* good base */
-    } else {
-      base_val = 10;
-      rb_raise(rb_eRangeError, "base must be within [2, 62] or [-36, -2].");
-    }
-  } else if (SYMBOL_P(base)) {
-    base_id = rb_to_id(base);
-    if (base_id == bin_base_id) {
-      base_val =  2;
-    } else if (base_id == oct_base_id) {
-      base_val =  8;
-    } else if (base_id == dec_base_id) {
-      base_val = 10;
-    } else if (base_id == hex_base_id) {
-      base_val = 16;
-    } else {
-      base_val = 10;  /* should raise an exception here. */
-    }
-  }
+  VALUE base_val;
+  unsigned int base;
 
-  Data_Get_Struct(self, MP_INT, self_val);
-  str = mpz_get_str(NULL, base_val, self_val);
+  rb_scan_args(argc, argv, "01", &base_val);
+  if (NIL_P(base_val)) { base = 10; }                /* default value */
+  else { base = get_base(base_val); }
+
+  Data_Get_Struct(self_val, MP_INT, self);
+  str = mpz_get_str(NULL, base, self);
   res = rb_str_new2(str);
   free (str);
 
@@ -1101,6 +1103,7 @@ VALUE r_gmpz_mul(VALUE self, VALUE arg)
     mpz_mul(res_val, self_val, arg_val);
   } else if (FIXNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
+    /* TODO: use mpz_mul_ui */
     mpz_mul_si(res_val, self_val, FIX2NUM(arg));
   } else if (GMPQ_P(arg)) {
     return r_gmpq_mul(arg, self);
@@ -1293,6 +1296,12 @@ DEFUN_INT2INT(abs, mpz_abs)
  * * GMP::Q
  * * GMP::F
  * * Bignum
+ *
+ * If _b_ is a GMP::Z, Fixnum, GMP::Q, or Bignum, then no division is actually
+ * performed. Instead, we simply construct a new GMP::Q number, using _a_ and
+ * _b_ as the numerator and denominator (not exactly true for the GMP::Q case).
+ *
+ * If _b_ is a GMP::F, then the result is calculated via `mpf_div`.
  */
 VALUE r_gmpz_div(VALUE self, VALUE arg)
 {
@@ -2344,7 +2353,27 @@ DEFUN_INT_SINGLETON_UI(primorial,  mpz_primorial_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)
+
+/*
+ * Document-method: GMP::Z.fib2
+ *
+ * call-seq:
+ *   GMP::Z.fib2(n)
+ *
+ * Returns [<i>F[n]</i>, <i>F[n-1]</i>], the <i>n</i>th and <i>n-1</i>th Fibonacci numbers.
+ *
+ * Examples:
+ * * GMP::Z.fib2(1)  #=> [ 1, 0]
+ * * GMP::Z.fib2(2)  #=> [ 1, 1]
+ * * GMP::Z.fib2(3)  #=> [ 2, 1]
+ * * GMP::Z.fib2(4)  #=> [ 3, 2]
+ * * GMP::Z.fib2(5)  #=> [ 5, 3]
+ * * GMP::Z.fib2(6)  #=> [ 8, 5]
+ * * GMP::Z.fib2(7)  #=> [13, 8]
+ */
+DEFUN_INT_SINGLETON_ZZ_UI(fib2, mpz_fib2_ui)
+
 DEFUN_INT_SINGLETON_UI(lucnum, mpz_lucnum_ui)
 
 
@@ -3034,6 +3063,7 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "to_i", r_gmpz_to_i, 0);
   rb_define_method(cGMP_Z, "to_d", r_gmpz_to_d, 0);
   rb_define_method(cGMP_Z, "to_s", r_gmpz_to_s, -1);
+  rb_define_alias(cGMP_Z, "inspect", "to_s");
 
   // Integer Arithmetic
   rb_define_method(cGMP_Z, "+",       r_gmpz_add, 1);
@@ -3122,6 +3152,7 @@ void init_gmpz()
   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, "fib2",          r_gmpzsg_fib2,      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);

data/ext/ruby_gmp.h

@@ -154,6 +154,8 @@ extern VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F, cGMP_RandState;
 extern VALUE cGMP_Rnd;
 #endif /* MPFR */
 
+extern int get_base(VALUE base_val);
+
 extern void r_gmpz_free(void *ptr);
 extern void r_gmpq_free(void *ptr);
 extern void r_gmpf_free(void *ptr);

data/manual.tex

@@ -34,8 +34,8 @@
 \huge{gmp} &\\
 \midrule[3pt]
 \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
-\multicolumn{2}{r}{\large{Edition 0.6.7}}\\
-\multicolumn{2}{r}{\large{9 December 2012}}
+\multicolumn{2}{r}{\large{Edition 0.6.41}}\\
+\multicolumn{2}{r}{\large{15 October 2013}}
 \end{tabular}
 
 \vfill
@@ -45,9 +45,9 @@
 
 \vfill
 This manual describes how to use the gmp Ruby gem, which provides bindings to
-the GNU multiple precision arithmetic library, version 4.3.x or 5.0.x.\\
+the GNU multiple precision arithmetic library, version 4.3.x or 5.x.\\
 \\
-Copyright 2009, 2010, 2011, 2012 Sam Rawlins.\\
+Copyright 2009, 2010, 2011, 2012, 2013 Sam Rawlins.\\
 No license yet.
 \newpage
 
@@ -143,9 +143,9 @@ OK. First, we've got a few requirements. To install the gmp gem, you need one
 of the following versions of Ruby:
 \begin{itemize}
   \item (MRI) Ruby 1.8.6 - tested lightly.
-  \item (MRI) Ruby 1.8.7 - tested seriously.
-  \item (MRI) Ruby 1.9.1 - tested seriously.
-  \item (MRI) Ruby 1.9.2 - tested seriously.
+  \item (MRI) Ruby 1.8.7 - tested lightly.
+  \item (MRI) Ruby 1.9.3 - tested seriously.
+  \item (MRI) Ruby 2.0.0 - tested seriously.
   \item (REE) Ruby 1.8.7 - tested lightly.
   \item (RBX) Rubinius 1.1 - tested lightly.
 \end{itemize}
@@ -854,7 +854,17 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \textbf{fib} & & GMP::Z.fib($n$) $\rightarrow$ $integer$ \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns $F[n]$, or, the $n$th Fibonacci number.
+  Returns $F[n]$, the $n$th Fibonacci number.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{fib2} & & GMP::Z.fib2($n$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns $F[n]$ and $F[n-1]$, the $n$th and $n-1$th Fibonacci numbers.
 }
 \end{tabular}
 

data/test/tc_division.rb

@@ -15,23 +15,13 @@ class TC_division < Test::Unit::TestCase
     assert_equal(GMP::Q, (@a / 3    ).class, "GMP::Z / Fixnum should be GMP::Q.")
     assert_equal(GMP::Q, (@a / 2**32).class, "GMP::Z / Bignum should be GMP::Q.")
     assert_equal(GMP::Q, (@a / @c   ).class, "GMP::Z / GMP::Z should be GMP::Q.")
-    begin
+
     assert_in_delta(0.7142857142, @a / @b, 1e-7, "GMP::Z./ should work.")
     assert_in_delta(1.4         , @b / @a, 1e-7, "GMP::Z./ should work.")
     assert_in_delta(1.6666666667, @a /  3, 1e-7, "GMP::Z./ should work.")
     assert_in_delta(0.6         ,  3 / @a, 1e-7, "GMP::Z./ should work.")
     assert_in_delta(0.2         , @a / @c, 1e-7, "GMP::Z./ should work.")
     assert_in_delta(5.0         , @c / @a, 1e-7, "GMP::Z./ should work.")
-    rescue TypeError => e
-      if e.message == "GMP::Q can't be coerced into Float"
-        #puts ""
-        print "[Suppressing error that should be fixed with a recent version of Test::Unit installed]"
-        #puts "installed."
-      else
-        puts "Accidentally rescued TypeError with message \"#{e.message}\", raising..."
-        raise e
-      end
-    end
   end
   
   def test_z_tdiv

data/test/tc_f_to_s.rb

@@ -63,13 +63,16 @@ class TC_F_to_s < Test::Unit::TestCase
     f = GMP::F(0.5)
     assert_equal("0.50000000000000000e+0",                                     f.to_s)
     assert_equal("0.10000000000000000000000000000000000000000000000000000e+0", f.to_s(2))
+    assert_equal("0.10000000000000000000000000000000000000000000000000000e+0", f.to_s(:bin))
     assert_equal("0.11111111111111111111111111111111112e+0",                   f.to_s(3))
     assert_equal("0.200000000000000000000000000e+0",                           f.to_s(4))
+    assert_equal("0.50000000000000000e+0",                                     f.inspect)
 
     g = GMP::F(0.8)
     assert_equal("0.80000000000000004e+0",                   g.to_s)
     assert_equal("0.21012101210121012101210121012101220e+0", g.to_s(3))
     assert_equal("0.400000000000000000000003e+0",            g.to_s(5))
     assert_equal("0.k00000000002ge+0",                       g.to_s(25))
+    assert_equal("0.80000000000000004e+0",                   g.inspect)
   end
 end

data/test/tc_fib_fac_nextprime.rb

@@ -2,15 +2,20 @@ require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
 
 class TC_fib_fac_nextprime < Test::Unit::TestCase
   def setup
-    @z10 = GMP::Z.new(10)
+     @z0 = GMP::Z.new( 0)
+     @z1 = GMP::Z.new( 1)
+     @z2 = GMP::Z.new( 2)
      @z7 = GMP::Z.new( 7)
      @z8 = GMP::Z.new( 8)
+    @z10 = GMP::Z.new(10)
     @z11 = GMP::Z.new(11)
     @z13 = GMP::Z.new(13)
     @z17 = GMP::Z.new(17)
     @z19 = GMP::Z.new(19)
+    @z34 = GMP::Z.new(34)
+    @z55 = GMP::Z.new(55)
   end
-  
+
   def test_fib
     assert_equal(  1, GMP::Z.fib(   1), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
     assert_equal(  1, GMP::Z.fib(   2), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
@@ -19,6 +24,7 @@ class TC_fib_fac_nextprime < Test::Unit::TestCase
     assert_equal(  5, GMP::Z.fib(   5), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
     assert_equal(  8, GMP::Z.fib(   6), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
     assert_equal( 13, GMP::Z.fib(   7), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 13, GMP::Z.fib( @z7), "GMP::Z::fib(x : GMP::Z) should be calculated correctly.")
     assert_equal( 21, GMP::Z.fib(   8), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
     assert_equal( 34, GMP::Z.fib(   9), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
     assert_equal( 55, GMP::Z.fib(  10), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
@@ -27,8 +33,24 @@ class TC_fib_fac_nextprime < Test::Unit::TestCase
     assert_equal(144, GMP::Z.fib(  12), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
     assert_equal(233, GMP::Z.fib(  13), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
     assert_equal(377, GMP::Z.fib(  14), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+
+    assert_raise(RangeError) { GMP::Z.fib(-1) }
+    assert_raise(RangeError) { GMP::Z.fib(GMP::Z(-1)) }
   end
-  
+
+  def test_fib2
+    assert_equal([ @z1, @z0], GMP::Z.fib2(   1), "GMP::Z::fib2(x : Fixnum) should be calculated correctly.")
+    assert_equal([ @z1, @z1], GMP::Z.fib2(   2), "GMP::Z::fib2(x : Fixnum) should be calculated correctly.")
+    assert_equal([ @z2, @z1], GMP::Z.fib2(   3), "GMP::Z::fib2(x : Fixnum) should be calculated correctly.")
+    assert_equal([@z13, @z8], GMP::Z.fib2(   7), "GMP::Z::fib2(x : Fixnum) should be calculated correctly.")
+    assert_equal([@z13, @z8], GMP::Z.fib2( @z7), "GMP::Z::fib2(x : GMP::Z) should be calculated correctly.")
+    assert_equal([@z55,@z34], GMP::Z.fib2(  10), "GMP::Z::fib2(x : Fixnum) should be calculated correctly.")
+    assert_equal([@z55,@z34], GMP::Z.fib2(@z10), "GMP::Z::fib2(x : GMP::Z) should be calculated correctly.")
+
+    assert_raise(RangeError) { GMP::Z.fib2(-1) }
+    assert_raise(RangeError) { GMP::Z.fib2(GMP::Z(-1)) }
+  end
+
   def test_fac
     assert_equal(   1, GMP::Z.fac( 0), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
     assert_equal(   1, GMP::Z.fac( 1), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
@@ -38,6 +60,9 @@ class TC_fib_fac_nextprime < Test::Unit::TestCase
     assert_equal( 120, GMP::Z.fac( 5), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
     assert_equal( 720, GMP::Z.fac( 6), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
     assert_equal(5040, GMP::Z.fac( 7), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+
+    assert_raise(RangeError) { GMP::Z.fac(-1) }
+    assert_raise(RangeError) { GMP::Z.fac(GMP::Z(-1)) }
   end
 
   def test_nextprime

data/test/tc_q.rb

@@ -115,5 +115,7 @@ class TC_Q < Test::Unit::TestCase
     assert_equal("0", GMP::Q(0,1).to_s, "GMP::Q should to_s properly.")
     assert_equal("0", GMP::Q(0,2000).to_s, "GMP::Q should to_s properly.")
     assert_equal("0", GMP::Q(0,-2000).to_s, "GMP::Q should to_s properly.")
+
+    assert_equal("1/2", GMP::Q(1,2).inspect, "GMP::Q should inspect properly.")
   end
 end

data/test/tc_z_to_dis.rb

@@ -50,7 +50,7 @@ class TC_to_i_to_d < Test::Unit::TestCase
     assert_equal(                  "-726746425", @d.to_s(:oct), "GMP::Z should to_s correctly.")
     assert_equal(                  "-123456789", @d.to_s(:dec), "GMP::Z should to_s correctly.")
     assert_equal(                    "-75bcd15", @d.to_s(:hex), "GMP::Z should to_s correctly.")
-    
+
     assert_equal("1",          GMP::Z.new(1).to_s,          "Z(1).to_s should equal '1'")
     assert_equal("-1",         GMP::Z.new(-1).to_s,         "Z(1).to_s should equal '-1'")
     assert_equal("1234567890", GMP::Z.new(1234567890).to_s, "GMP::Z should to_s correctly.")
@@ -65,5 +65,8 @@ class TC_to_i_to_d < Test::Unit::TestCase
     assert_equal("377",        GMP::Z.new(255).to_s(:oct),  "GMP::Z should to_s(:oct) correctly.")
     assert_equal("255",        GMP::Z.new(255).to_s(:dec),  "GMP::Z should to_s(:dec) correctly.")
     assert_equal("ff",         GMP::Z.new(255).to_s(:hex),  "GMP::Z should to_s(:hex) correctly.")
+
+    assert_equal("1",          GMP::Z.new(1).inspect,       "Z(1).inspect should equal '1'")
+    assert_equal("-1",         GMP::Z.new(-1).inspect,      "Z(1).inspect should equal '-1'")
   end
 end

data/test/unit_tests.rb

@@ -1,55 +1,55 @@
 #!/usr/bin/env ruby
 
-#require './test_helper'
+DIR = File.expand_path(File.dirname(__FILE__))
 
-require './tc_constants'
-require './tc_division'
-require './tc_f_precision'
-require './tc_f_arithmetics_coersion'
-require './tc_f_to_s'
-require './tc_z'
-require './tc_z_basic'
-require './tc_z_addmul'
-require './tc_z_submul'
-require './tc_z_logic'
-require './tc_z_exponentiation'
-require './tc_z_export_import'
-require './tc_z_hamdist'
-require './tc_z_io'
-require './tc_z_to_dis'
-require './tc_z_shifts_last_bits'
-require './tc_z_jac_leg_rem'
-require './tc_z_gcd_lcm_invert'
-require './tc_q'
-require './tc_q_basic'
-require './tc_cmp'
-require './tc_zerodivisionexceptions'
-require './tc_sgn_neg_abs'
-require './tc_fib_fac_nextprime'
-require './tc_swap'
-require './tc_floor_ceil_truncate'
-require './tc_logical_roots'
-require './tc_random'
-require './tc_hashes'
-require './tc_z_functional_mappings'
+require File.join(DIR, 'tc_constants')
+require File.join(DIR, 'tc_division')
+require File.join(DIR, 'tc_f_precision')
+require File.join(DIR, 'tc_f_arithmetics_coersion')
+require File.join(DIR, 'tc_f_to_s')
+require File.join(DIR, 'tc_z')
+require File.join(DIR, 'tc_z_basic')
+require File.join(DIR, 'tc_z_addmul')
+require File.join(DIR, 'tc_z_submul')
+require File.join(DIR, 'tc_z_logic')
+require File.join(DIR, 'tc_z_exponentiation')
+require File.join(DIR, 'tc_z_export_import')
+require File.join(DIR, 'tc_z_hamdist')
+require File.join(DIR, 'tc_z_io')
+require File.join(DIR, 'tc_z_to_dis')
+require File.join(DIR, 'tc_z_shifts_last_bits')
+require File.join(DIR, 'tc_z_jac_leg_rem')
+require File.join(DIR, 'tc_z_gcd_lcm_invert')
+require File.join(DIR, 'tc_q')
+require File.join(DIR, 'tc_q_basic')
+require File.join(DIR, 'tc_cmp')
+require File.join(DIR, 'tc_zerodivisionexceptions')
+require File.join(DIR, 'tc_sgn_neg_abs')
+require File.join(DIR, 'tc_fib_fac_nextprime')
+require File.join(DIR, 'tc_swap')
+require File.join(DIR, 'tc_floor_ceil_truncate')
+require File.join(DIR, 'tc_logical_roots')
+require File.join(DIR, 'tc_random')
+require File.join(DIR, 'tc_hashes')
+require File.join(DIR, 'tc_z_functional_mappings')
 
-require './gmp_tcong'
-require './gmp_tgcd'
-require './gmp_tlcm'
-require './gmp_tprintf'
-require './gmp_troot'
+require File.join(DIR, 'gmp_tcong')
+require File.join(DIR, 'gmp_tgcd')
+require File.join(DIR, 'gmp_tlcm')
+require File.join(DIR, 'gmp_tprintf')
+require File.join(DIR, 'gmp_troot')
 
 begin
   GMP::MPFR_VERSION
-  require './tc_mpfr_constants'
-  require './tc_mpfr_integer'
-  require './tc_mpfr_random'
-  require './tc_mpfr_functions'
-  require './tc_mpfr_rounding'
-  require './mpfr_tcbrt'
-  require './mpfr_tisnan'
-  require './mpfr_trec_sqrt'
-  require './mpfr_tsqrt'
+  require File.join(DIR, 'tc_mpfr_constants')
+  require File.join(DIR, 'tc_mpfr_integer')
+  require File.join(DIR, 'tc_mpfr_random')
+  require File.join(DIR, 'tc_mpfr_functions')
+  require File.join(DIR, 'tc_mpfr_rounding')
+  require File.join(DIR, 'mpfr_tcbrt')
+  require File.join(DIR, 'mpfr_tisnan')
+  require File.join(DIR, 'mpfr_trec_sqrt')
+  require File.join(DIR, 'mpfr_tsqrt')
 rescue
 
 end

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gmp
 version: !ruby/object:Gem::Version
-  version: 0.6.31
-  prerelease: 
+  version: 0.6.41
 platform: ruby
 authors:
 - Tomasz Wegrzanowski
@@ -10,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-06 00:00:00.000000000 Z
+date: 2013-10-15 00:00:00.000000000 Z
 dependencies: []
 description: gmp - providing Ruby bindings to the GMP library.
 email:
@@ -89,8 +88,11 @@ files:
 - test/unit_tests.rb
 - test/README
 - test/test_unit/assertions.rb
-- benchmark/benchmark-results-5.0.5_1.9.3_0.6.7.ods
-- benchmark/benchmark-results-5.1.0_0.6.19.ods
+- benchmark/bench.sh
+- benchmark/csv.sh
+- benchmark/results-5.0.5_1.9.3_0.6.7.ods
+- benchmark/results-5.1.0_0.6.19.ods
+- benchmark/results-5.1.3_0.6.31.ods
 - CHANGELOG
 - INSTALL
 - README.html
@@ -103,28 +105,26 @@ files:
 - performance.2012.pdf
 homepage: http://github.com/srawlins/gmp
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: 1.8.6
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements:
 - GMP compiled and working properly.
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.1.8
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Provides Ruby bindings to the GMP library.
 test_files: []
-has_rdoc: yard