gmp 0.5.47 → 0.6.7

data/ext/gmpz.c

@@ -605,6 +605,21 @@ VALUE r_gmpzsg_new(int argc, VALUE *argv, VALUE klass)
   return res;
 }
 
+static VALUE r_gmpz_alloc(VALUE klass) {
+  MP_INT *z;
+  VALUE obj;
+
+  //mpz_init(z);
+  //obj = Data_Make_Struct(klass, MP_INT, 0, r_gmpz_free, z);
+  //obj = Data_Wrap_Struct(klass, 0, r_gmpz_free, z);
+//  mpz_make_struct_init (z, obj);
+ // mpz_make_struct_init (obj, z);
+  obj = Data_Make_Struct(klass, MP_INT, 0, r_gmpz_free, z);
+  mpz_init (z);
+
+  return obj;
+}
+
 VALUE r_gmpz_initialize(int argc, VALUE *argv, VALUE self)
 {
   MP_INT *self_val;
@@ -636,6 +651,22 @@ VALUE r_gmpz_initialize(int argc, VALUE *argv, VALUE self)
   return Qnil;
 }
 
+static VALUE r_gmpz_initialize_copy(VALUE copy, VALUE orig) {
+  MP_INT *orig_z, *copy_z;
+
+  if (copy == orig) return copy;
+
+  if (TYPE(orig) != T_DATA) {
+    rb_raise(rb_eTypeError, "wrong argument type");
+  }
+
+  mpz_get_struct (orig, orig_z);
+  mpz_get_struct (copy, copy_z);
+  mpz_set (copy_z, orig_z);
+
+  return copy;
+}
+
 /*
  * call-seq:
  *   a = b
@@ -1776,8 +1807,8 @@ VALUE r_gmpz_gcdext(VALUE self, VALUE arg)
     mpz_make_struct_init (res, res_val);
     mpz_make_struct_init (s, s_val);
     mpz_make_struct_init (t, t_val);
-    mpz_temp_alloc(arg_val);
-    mpz_init_set_ui(arg_val, FIX2NUM(arg));
+    mpz_temp_alloc (arg_val);
+    mpz_init_set_ui (arg_val, FIX2NUM(arg));
     free_arg_val = 1;
     mpz_gcdext (res_val, s_val, t_val, self_val, arg_val);
   } else if (BIGNUM_P (arg)) {
@@ -1789,14 +1820,94 @@ VALUE r_gmpz_gcdext(VALUE self, VALUE arg)
   } else {
     typeerror (ZXB);
   }
-  
+
   if (free_arg_val)
-    mpz_temp_free(arg_val);
-  
-  ary = rb_ary_new3(3, res, s, t);
+    mpz_temp_free (arg_val);
+
+  ary = rb_ary_new3 (3, res, s, t);
+  return ary;
+}
+
+/*
+ * call-seq:
+ *   a.gcdext2(b) #=> g, s
+ *
+ * @since 0.5.x
+ *
+ * Returns the greatest common divisor of _a_ and _b_, in addition to _s_, the
+ * coefficient satisfying <i>a*s + b*t = g</i>. _g_ is always positive, even if one or
+ * both of _a_ and _b_ are negative. _s_ and _t_ are chosen such that
+ * <i>abs(s) <= abs(b)</i> and <i>abs(t) <= abs(a)</i>.
+ */
+VALUE r_gmpz_gcdext2(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val, *res_val, *s_val;
+  VALUE res, s, ary;
+  int free_arg_val = 0;
+
+  mpz_get_struct (self,self_val);
+
+  if (GMPZ_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_make_struct_init (s, s_val);
+    mpz_get_struct (arg, arg_val);
+    mpz_gcdext (res_val, s_val, NULL, self_val, arg_val);
+  } else if (FIXNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_make_struct_init (s, s_val);
+    mpz_temp_alloc (arg_val);
+    mpz_init_set_ui (arg_val, FIX2NUM(arg));
+    free_arg_val = 1;
+    mpz_gcdext (res_val, s_val, NULL, self_val, arg_val);
+  } else if (BIGNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_make_struct_init (s, s_val);
+    mpz_set_bignum (res_val, arg);
+    mpz_gcdext (res_val, s_val, NULL, res_val, self_val);
+  } else {
+    typeerror (ZXB);
+  }
+
+  if (free_arg_val)
+    mpz_temp_free (arg_val);
+
+  ary = rb_ary_new3 (2, res, s);
   return ary;
 }
 
+/*
+ * call-seq:
+ *   a.lcm(b)
+ *
+ * @since 0.2.11
+ *
+ * Returns the least common multiple of a and b. The result is always positive even if
+ * one or both of _a_ or _b_ are negative.
+ */
+VALUE r_gmpz_lcm(VALUE self, VALUE arg)
+{
+  MP_INT *self_val, *arg_val, *res_val;
+  VALUE res;
+
+  mpz_get_struct (self,self_val);
+
+  if (GMPZ_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_get_struct (arg, arg_val);
+    mpz_lcm (res_val, self_val, arg_val);
+  } else if (FIXNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_lcm_ui (res_val, self_val, FIX2NUM(arg));
+  } else if (BIGNUM_P (arg)) {
+    mpz_make_struct_init (res, res_val);
+    mpz_set_bignum (res_val, arg);
+    mpz_lcm (res_val, res_val, self_val);
+  } else {
+    typeerror (ZXB);
+  }
+  return res;
+}
+
 /*
  * call-seq:
  *   a.invert(b)
@@ -2536,15 +2647,17 @@ void init_gmpz()
   cGMP_Z = rb_define_class_under(mGMP, "Z", rb_cInteger);
 
   // Initializing, Assigning Integers
-  rb_define_singleton_method(cGMP_Z, "new", r_gmpzsg_new, -1);
-  rb_define_method(cGMP_Z, "initialize",    r_gmpz_initialize, -1);
-  rb_define_method(cGMP_Z, "swap",          r_gmpz_swap, 1);
+  rb_define_singleton_method(cGMP_Z, "new",   r_gmpzsg_new, -1);
+  rb_define_method(    cGMP_Z, "initialize",      r_gmpz_initialize, -1);
+  rb_define_method(    cGMP_Z, "initialize_copy", r_gmpz_initialize_copy, 1);
+  rb_define_alloc_func(cGMP_Z,                    r_gmpz_alloc);
+  rb_define_method(    cGMP_Z, "swap",            r_gmpz_swap, 1);
 
   // Converting Integers
   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);
-  
+
   // Integer Arithmetic
   rb_define_method(cGMP_Z, "+",       r_gmpz_add, 1);
   rb_define_method(cGMP_Z, "add!",    r_gmpz_add_self, 1);
@@ -2568,7 +2681,7 @@ void init_gmpz()
   rb_define_singleton_method(cGMP_Z, "mul_2exp", r_gmpzsg_mul_2exp, 3);
   rb_define_singleton_method(cGMP_Z, "neg", r_gmpzsg_neg, 2);
   rb_define_singleton_method(cGMP_Z, "abs", r_gmpzsg_abs, 2);
-  
+
   // Integer Division
   rb_define_method(cGMP_Z, "/",            r_gmpz_div, 1);
   rb_define_method(cGMP_Z, "tdiv",         r_gmpz_tdiv, 1);
@@ -2591,7 +2704,7 @@ void init_gmpz()
   rb_define_singleton_method(cGMP_Z, "tdiv_r_2exp", r_gmpzsg_tdiv_r_2exp, 3);
   rb_define_singleton_method(cGMP_Z, "divisible?",  r_gmpzsg_divisible, 2);
   rb_define_singleton_method(cGMP_Z, "congruent?",  r_gmpzsg_congruent, 3);
-  
+
   // Integer Exponentiation
   rb_define_singleton_method(cGMP_Z, "pow",    r_gmpzsg_pow, 2);
   rb_define_method(cGMP_Z,           "**",     r_gmpz_pow, 1);
@@ -2606,26 +2719,28 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "power?",  r_gmpz_is_power, 0);
   // Functional Mappings
   rb_define_singleton_method(cGMP_Z, "sqrt", r_gmpzsg_sqrt, 2);
-  
+
   // Number Theoretic Functions
   rb_define_method(          cGMP_Z, "probab_prime?", r_gmpz_is_probab_prime, -1);
   rb_define_method(          cGMP_Z, "nextprime",     r_gmpz_nextprime, 0);
   rb_define_method(          cGMP_Z, "nextprime!",    r_gmpz_nextprime_self, 0);
   rb_define_alias(           cGMP_Z, "next_prime",    "nextprime");
   rb_define_alias(           cGMP_Z, "next_prime!",   "nextprime!");
-  rb_define_method(          cGMP_Z, "gcd",           r_gmpz_gcd, 1);
-  rb_define_method(          cGMP_Z, "gcdext",        r_gmpz_gcdext, 1);
-  rb_define_method(          cGMP_Z, "invert",        r_gmpz_invert, 1);
-  rb_define_method(          cGMP_Z, "jacobi",        r_gmpz_jacobi, 1);
-  rb_define_singleton_method(cGMP_Z, "jacobi",        r_gmpzsg_jacobi, 2);
-  rb_define_method(          cGMP_Z, "legendre",      r_gmpz_legendre, 1);
-  rb_define_method(          cGMP_Z, "remove",        r_gmpz_remove, 1);
-  rb_define_singleton_method(cGMP_Z, "fac",           r_gmpzsg_fac, 1);
-  rb_define_singleton_method(cGMP_Z, "fib",           r_gmpzsg_fib, 1);
+  rb_define_method(          cGMP_Z, "gcd",           r_gmpz_gcd,         1);
+  rb_define_method(          cGMP_Z, "gcdext",        r_gmpz_gcdext,      1);
+  rb_define_method(          cGMP_Z, "gcdext2",       r_gmpz_gcdext2,     1);
+  rb_define_method(          cGMP_Z, "lcm",           r_gmpz_lcm,         1);
+  rb_define_method(          cGMP_Z, "invert",        r_gmpz_invert,      1);
+  rb_define_method(          cGMP_Z, "jacobi",        r_gmpz_jacobi,      1);
+  rb_define_singleton_method(cGMP_Z, "jacobi",        r_gmpzsg_jacobi,    2);
+  rb_define_method(          cGMP_Z, "legendre",      r_gmpz_legendre,    1);
+  rb_define_method(          cGMP_Z, "remove",        r_gmpz_remove,      1);
+  rb_define_singleton_method(cGMP_Z, "fac",           r_gmpzsg_fac,       1);
+  rb_define_singleton_method(cGMP_Z, "fib",           r_gmpzsg_fib,       1);
   // Functional Mappings
-  rb_define_singleton_method(cGMP_Z, "lcm", r_gmpzsg_lcm, 3);
-  rb_define_singleton_method(cGMP_Z, "nextprime", r_gmpzsg_nextprime, 2);
-  
+  rb_define_singleton_method(cGMP_Z, "lcm",           r_gmpzsg_lcm,       3);
+  rb_define_singleton_method(cGMP_Z, "nextprime",     r_gmpzsg_nextprime, 2);
+
   // Integer Comparisons
   rb_define_method(cGMP_Z, "<=>",     r_gmpz_cmp, 1);
   rb_define_method(cGMP_Z, ">",       r_gmpz_cmp_gt, 1);
@@ -2635,10 +2750,10 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "<=",      r_gmpz_cmp_le, 1);
   rb_define_method(cGMP_Z, "cmpabs",  r_gmpz_cmpabs, 1);
   rb_define_method(cGMP_Z, "sgn",     r_gmpz_sgn, 0);
-  
+
   rb_define_method(cGMP_Z, "eql?",    r_gmpz_eql, 1);
   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);
@@ -2652,17 +2767,17 @@ void init_gmpz()
   rb_define_method(cGMP_Z, "[]",       r_gmpz_getbit, 1);
   // Functional Mappings
   rb_define_singleton_method(cGMP_Z, "com", r_gmpzsg_com, 2);
-  
+
   // Miscellaneous Integer Functions
   rb_define_method(cGMP_Z, "even?", r_gmpz_is_even, 0);
   rb_define_method(cGMP_Z, "odd?", r_gmpz_is_odd, 0);
   rb_define_method(cGMP_Z, "sizeinbase", r_gmpz_sizeinbase, 1);
   rb_define_alias( cGMP_Z, "size_in_base", "sizeinbase");
   rb_define_method(cGMP_Z, "size_in_bin", r_gmpz_size_in_bin, 0);
-  
+
   // Integer Special Functions
   rb_define_method(cGMP_Z, "size", r_gmpz_size, 0);
-  
+
   // _unsorted_
   rb_define_method(cGMP_Z, ">>",  r_gmpz_fshr, 1);
   rb_define_method(cGMP_Z, "lastbits_pos",  r_gmpz_fshrm, 1);

data/ext/mprnd.c

@@ -10,7 +10,7 @@ VALUE r_mprndsg_new(int argc, VALUE *argv, VALUE klass)
   int *res_value;
   (void)klass;
   res_value = 0;
-  
+
   mprnd_make_struct(res, res_value);
   rb_obj_call_init(res, argc, argv);
   return res;
@@ -19,10 +19,10 @@ VALUE r_mprndsg_new(int argc, VALUE *argv, VALUE klass)
 VALUE r_mprnd_initialize(int argc, VALUE *argv, VALUE self)
 {
   VALUE mode, name, ieee754;
-  mode = argv[0];
-  (void)argc;
   const char *prefix;
   char name_val[10];
+  mode = argv[0];
+  (void)argc;
   if (MPFR_VERSION_MAJOR < 3)
     prefix = "GMP";
   else
@@ -66,19 +66,19 @@ VALUE r_mprnd_inspect(VALUE self)
 
 void init_gmprnd()
 {
-  mGMP = rb_define_module("GMP");
   ID new_id = rb_intern("new");
+  mGMP = rb_define_module("GMP");
 
   cGMP_Rnd = rb_define_class_under(mGMP, "Rnd", rb_cObject);
-  
+
   rb_define_singleton_method(cGMP_Rnd, "new", r_mprndsg_new, -1);
   rb_define_method(cGMP_Rnd, "initialize", r_mprnd_initialize, -1);
   rb_define_method(cGMP_Rnd, "inspect", r_mprnd_inspect, 0);
-  
+
   rb_define_attr (cGMP_Rnd, "mode",    1, 0);
   rb_define_attr (cGMP_Rnd, "name",    1, 0);
   rb_define_attr (cGMP_Rnd, "ieee754", 1, 0);
-  
+
   rb_define_const(mGMP, "GMP_RNDN", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(0)));
   rb_define_const(mGMP, "GMP_RNDZ", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(1)));
   rb_define_const(mGMP, "GMP_RNDU", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(2)));

data/ext/ruby_gmp.h

@@ -77,8 +77,8 @@ typedef __gmp_randstate_struct MP_RANDSTATE;
 #define mpz_temp_alloc(var) { var=malloc(sizeof(MP_INT)); }
 #define mpz_temp_init(var) { mpz_temp_alloc(var); mpz_init(var); }
 #define mpz_temp_from_bignum(var,var_bignum) {                 \
-  mpz_temp_alloc(var);                                         \
   VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32));  \
+  mpz_temp_alloc(var);                                         \
   mpz_init_set_str (var, StringValuePtr (tmp), 32);             \
 }
 #define mpz_temp_free(var) { mpz_clear(var); free(var); }
@@ -265,7 +265,7 @@ extern VALUE r_gmpf_set_prec_raw(VALUE self, VALUE arg);
 
 // Converting Floats
 extern VALUE r_gmpf_to_d(VALUE self);
-extern VALUE r_gmpf_to_s(VALUE self);
+extern VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self);
 
 // Float Arithmetic
 #ifndef MPFR

data/lib/gmp.rb

@@ -6,4 +6,25 @@ ENV['PATH'] = [File.expand_path(
   File.join(File.dirname(__FILE__), "..", "ext")
 ), ENV['PATH']].compact.join(';') if RbConfig::CONFIG['host_os'] =~ /(mswin|mingw|mingw32)/i
 
-require File.dirname(__FILE__) + '/../ext/gmp'
+require File.dirname(__FILE__) + '/../ext/gmp'
+
+unless RUBY_VERSION =~ /^1.8/
+  module GMP
+    def self.sprintf(format, *args)
+      first_pct = format.index '%'
+      result = format[0...first_pct]
+      #format.gsub(/(?<!%)%[0#+ ']*[0-9]*.?[0-9]*[a-zA-Z][^%]*/) do |fragment|
+      format.gsub(Regexp.new('(?<!%)%[0#+ \']*[0-9]*.?[0-9]*[a-zA-Z][^%]*')) do |fragment|
+        arg = args.shift
+        if fragment =~ /%[0#+ ']*[0-9]*.?[0-9]*[ZQF]/
+          result << sprintf2(fragment, arg)
+        elsif fragment =~ /%[0#+ ']*[0-9]*.?[0-9]*[PR]/ && GMP.const_defined?(:MPFR_VERSION)
+          result << GMP::F.sprintf2(fragment, arg)
+        else
+          result << (fragment % arg)
+        end
+      end
+      result
+    end
+  end
+end

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.5.47}}\\
-\multicolumn{2}{r}{\large{10 November 2011}}
+\multicolumn{2}{r}{\large{Edition 0.6.7}}\\
+\multicolumn{2}{r}{\large{9 December 2012}}
 \end{tabular}
 
 \vfill
@@ -47,7 +47,7 @@
 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.\\
 \\
-Copyright 2009, 2010, 2011 Sam Rawlins.\\
+Copyright 2009, 2010, 2011, 2012 Sam Rawlins.\\
 No license yet.
 \newpage
 
@@ -1525,110 +1525,6 @@ Every method below accepts two additional parameters in addition to any required
 \newpage
 \section{Benchmarking}
 
-Starting with, I believe, GMP 5.0.0, their benchmarking suite was updated to version 0.2,
-a significant improvement over version 0.1. The suite consists of 3 parts.\\\\
-
-First is six individual programs that will benchmark a single concept. These are
-\texttt{multiply}, \texttt{divide}, \texttt{gcd}, \texttt{gcdext}, \texttt{rsa}, and
-\texttt{pi}.
-
-Second is gexpr.c, a nifty little program (compiled with \texttt{gcc -o gexpr gexpr.c},
-or\\ \texttt{gcc -o gexpr gexpr.c -lm} on some systems). They use this basically for
-weighing the results of individual tests and stringifying them to a certain precision.
-
-Third is runbench, a shell script that runs each of the six benchmark programs, each
-several times with a different set of arguments. It compiles the results, using gexpr
-to carefully calculate a final "score" for each benchmark, each benchmark family
-(\texttt{rsa} and \texttt{pi} are separated as "app" benchmarks.), and for the suite as a
-whole.
-
-\subsection{gmp gem benchmarking}
-
-The structure described above lends itself perfectly to some simple modifications that
-allow me to benchmark the gmp gem. Instead of using the C programs that are the
-individual benchmarks, I have converted them into Ruby programs, and called them the same
-names. When runbench executes "multiply" for example, it is running a Ruby program that
-does the same general thing as "multiply" the C program. This allows me to benchmark the
-gmp gem, and I can even compare the results with those of benchmarking GMP itself. I have
-done so below.
-
-\newpage
-\subsection{Benchmark Results}
-
-I've benchmarked an array of Ruby-version/GMP-version combinations, which can be compared
-with results of the actual GMPbench benchmark, in order to understand the overhead that
-Ruby and the Ruby C Extension API impose on the GMP library. The benchmarks listed were
-all executed on an Apple MacBook "5.1." booting three operating systems with rEFIt 0.14.
-Because not all of the marks from GMPbench have been ported to the Ruby gmp gem, results
-for 'base' and 'app' are not listed; they cannot be compared with GMPbench results.\\
-
-\begin{LARGE}MacBook, Intel Core 2 Duo, 2 GHz, 2 GB DDR3\end{LARGE}\\
-
-Mac OS X 10.6.4, x86 (32-bit)\\
-Ruby and GMP compiled with gcc 4.2.1 (Apple Inc. build 5664)\\
-\begin{tabular}{|l|l|r|r|r|r|r|}
-  \hline
-  GMP   & bench    & Ruby 1.8.7 & Ruby 1.9.1 & Ruby 1.9.2 & RBX 1.1 & C \\
-  \hline
-  4.3.2 & multiply &  7734.2    &     7505.9 &     7637.9 &  7469.3 & 16789   \\
-        & divide   &  7336.1    &     7180   &     7223.7 &  7121.2 &  9872.5 \\
-        & gcd      &  2356      &     2436.8 &     2448.8 &  2385.6 &  2938.9 \\
-        & rsa      &  2035.2    &     1995.3 &     2068.4 &  2051.1 &  2136.7 \\
-  \hline
-  5.0.1 & multiply &  8030.5    &     7926.7 &     8019.3 &  7944.1 & 17925   \\
-        & divide   & 10341      &    10070   &    10218   & 10018   & 16069   \\
-        & gcd      &  2501      &     2535.4 &     2578.7 &  2537.3 &  3063.7 \\
-        & rsa      &  2128      &     2159.1 &     2170.5 &  2162   &  2229.2 \\
-  \hline
-\end{tabular}\\\\
-
-Ubuntu 10.04, Kernel 2.6.32-25, x86\_64 (64-bit)\\
-Ruby and GMP compiled with gcc 4.4.3 (Ubuntu 4.4.3-4ubuntu5)\\
-\begin{small}In these tests, the classic multiply benchmark crashes with OutOfMemory. There are
-two ways this has been remedied. The first (tests marked multiply.gc) is to manually
-kick off garbage collection every so often. This solves the memory problem in all
-interpreters except Rubinius 1.1 (investigation pending). The second, and far better
-solution is to employ the new functional mapping methods. These have not been
-documented yet, but documentation is pending, and high on my priority list. Simply
-put, these methods overcome the overhead (memory and time) of instantiating new
-objects all the time.\end{small}\\
-\begin{tabular}{|l|l|r|r|r|r|r|}
-  \hline
-  GMP   & bench        & Ruby 1.8.7 & Ruby 1.9.1 & Ruby 1.9.2 & RBX 1.1 & C \\
-  \hline
-  4.3.2 & multiply     &          x &          x &          x &       x & 14716   \\
-        & multiply.gc  &     7849.2 &     6911.4 &     7703.5 &       x & 14716   \\
-        & multiply.fnl &     9532.6 &    11182   &    10886   &  5131.3 & 14716   \\
-        & divide       &     7704.6 &     7591.8 &     7527.2 &  4265.1 &  8614.3 \\
-        & gcd          &     2420.1 &     2453.6 &     2487.4 &  1676.4 &  2779.8 \\
-        & rsa          &     2040.5 &     2069.2 &     2044.2 &  1758.9 &  1984.3 \\
-  \hline
-  5.0.1 & multiply     &          x &          x &          x &       x & 17695   \\
-        & multiply.gc  &     8265.3 &     7289.4 &     8105.1 &       x & 17695   \\
-        & multiply.fnl &    10029   &    11807   &    11493   &  6036.7 & 17695   \\
-        & divide       &    10988   &    10935   &    10799   &  6164.9 & 15629   \\
-        & gcd          &     2554.2 &     2510.2 &     2538.6 &  1802.8 &  2925.1 \\
-        & rsa          &     2128.7 &     2189   &     2179.9 &  1941.2 &  2233.4 \\
-  \hline
-\end{tabular}\\\\
-
-\newpage
-Windows 7 (64-bit)\\
-Ruby and GMP compiled with gcc 4.5.0 (tdm-1)\\
-\begin{tabular}{|l|l|r|r|r|r|}
-  \hline
-  GMP & bench & Ruby 1.8.7 & Ruby 1.9.1 & Ruby 1.9.2 & C \\
-  \hline
-  4.3.2 & multiply & 3607.9   & 3679.3  & 3655.5 & 6448.7 \\
-        & divide   & 3062.6   & 3103.7  & 3074.5 & 3717.5 \\
-        & gcd      & 1165     & 1190.6  & 1211.8 & 1359.4 \\
-        & rsa      & 733.87   &  729.9  & 742.22 & 757.97 \\
-  \hline
-  5.0.1 & multiply & 3792.1   & 3869    & 3785.9 & 6835.2 \\
-        & divide   & 4662.2   & 4704.4  & 4692.3 & 6497.4 \\
-        & gcd      & 1222.8   & 1249.7  & 1245   & 1394.2 \\
-        & rsa      &  742.78  &  745.66 & 739.9  & 754.72 \\
-  \hline
-\end{tabular}\\
+Benchmark results can be found in performance.pdf.
 
 \end{document}