gmp 0.4.7-x86-mingw32 → 0.5.3-x86-mingw32

data/ext/mprnd.c

@@ -21,27 +21,38 @@ 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];
+  if (MPFR_VERSION_MAJOR < 3)
+    prefix = "GMP";
+  else
+    prefix = "MPFR";
   switch (FIX2INT(mode)) {
   case 0:
-    name = rb_str_new2("GMP_RNDN");
+    sprintf(name_val, "%s_RNDN", prefix);
     ieee754 = rb_str_new2("roundTiesToEven");
     break;
   case 1:
-    name = rb_str_new2("GMP_RNDZ");
+    sprintf(name_val, "%s_RNDZ", prefix);
     ieee754 = rb_str_new2("roundTowardZero");
     break;
   case 2:
-    name = rb_str_new2("GMP_RNDU");
+    sprintf(name_val, "%s_RNDU", prefix);
     ieee754 = rb_str_new2("roundTowardPositive");
     break;
   case 3:
-    name = rb_str_new2("GMP_RNDD");
+    sprintf(name_val, "%s_RNDD", prefix);
     ieee754 = rb_str_new2("roundTowardNegative");
     break;
+  case 4:
+    sprintf(name_val, "%s_RNDA", prefix);
+    ieee754 = rb_str_new2("roundAwayFromZero");
+    break;
   default:
-    name = rb_str_new2("GMP_RNDN");
+    sprintf(name_val, "%s_RNDN", prefix);
     ieee754 = rb_str_new2("roundTiesToEven");
   }
+  name = rb_str_new2(name_val);
   rb_iv_set(self, "@mode",    mode);
   rb_iv_set(self, "@name", name);
   rb_iv_set(self, "@ieee754", ieee754);
@@ -72,6 +83,13 @@ void init_gmprnd()
   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)));
   rb_define_const(mGMP, "GMP_RNDD", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(3)));
+  /* MPFR 3.0.0 */
+  rb_define_const(mGMP, "MPFR_RNDN", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(0)));
+  rb_define_const(mGMP, "MPFR_RNDZ", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(1)));
+  rb_define_const(mGMP, "MPFR_RNDU", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(2)));
+  rb_define_const(mGMP, "MPFR_RNDD", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(3)));
+  rb_define_const(mGMP, "MPFR_RNDA", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(4)));
+  /* end MPFR 3.0.0 */
 }
 
 #endif /* MPFR */

data/ext/ruby_gmp.h

@@ -40,38 +40,90 @@ typedef __mpf_struct MP_FLOAT;
 */
 typedef __gmp_randstate_struct MP_RANDSTATE;
 
+/*
+ * Here, MPFR is not included, so we are pure GMP. In GMP, mpf_get_prec returns
+ * an unsigned long int, so we will too.
+ */
+#ifndef MPFR
+typedef unsigned long mpfr_prec_t;
+/*
+ * Here, MPFR is not included, so we are pure GMP. In GMP, mpf_get_prec returns
+ * an unsigned long int, so we will too.
+ */
+#endif
+
 #define mpz_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_INT, c_var); }
 #define mpq_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RAT, c_var); }
 #define mpf_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_FLOAT, c_var); }
 #define mprandstate_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RANDSTATE, c_var); }
-#define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpf_get_prec(c_var); }
 #define mpz_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Z, MP_INT, 0, r_gmpz_free, c_var); }
 #define mpq_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Q, MP_RAT, 0, r_gmpq_free, c_var); }
 #define mpf_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_F, MP_FLOAT, 0, r_gmpf_free, c_var); }
 #define mprandstate_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_RandState, MP_RANDSTATE, 0, r_gmprandstate_free, c_var); }
 #define mpz_make_struct_init(ruby_var,c_var) { mpz_make_struct(ruby_var,c_var); mpz_init (c_var); }
 #define mpq_make_struct_init(ruby_var,c_var) { mpq_make_struct(ruby_var,c_var); mpq_init (c_var); }
-#define mpf_make_struct_init(ruby_var,c_var,prec) { mpf_make_struct(ruby_var,c_var); mpf_init2 (c_var,prec); }
 #define BIGNUM_P(value) (TYPE(value) == T_BIGNUM)
 #define FLOAT_P(value)  (TYPE(value) == T_FLOAT)
 #define STRING_P(value) (TYPE(value) == T_STRING)
 #define GMPZ_P(value)   (rb_obj_is_instance_of(value, cGMP_Z) == Qtrue)
 #define GMPQ_P(value)   (rb_obj_is_instance_of(value, cGMP_Q) == Qtrue)
 #define GMPF_P(value)   (rb_obj_is_instance_of(value, cGMP_F) == Qtrue)
-#define mpz_set_bignum(var_mpz,var_bignum) \
-  mpz_set_str (var_mpz, STR2CSTR (rb_funcall (var_bignum, rb_intern ("to_s"), 0)), 0);
+#define mpz_set_bignum(var_mpz,var_bignum) {                   \
+  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 0);  \
+  mpz_set_str (var_mpz, StringValuePtr (tmp), 0);              \
+}
 #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); mpz_init_set_str(var, STR2CSTR(rb_funcall(var_bignum, rb_intern("to_s"), 0)), 0); }
+#define mpz_temp_from_bignum(var,var_bignum) {                 \
+  mpz_temp_alloc(var);                                         \
+  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 0);  \
+  mpz_init_set_str (var, StringValuePtr (tmp), 0);             \
+}
 #define mpz_temp_free(var) { mpz_clear(var); free(var); }
 #define mpf_temp_alloc(var) { var=malloc(sizeof(MP_FLOAT)); }
+#if defined(MPFR) && defined(HAVE_MPFR_H)
+#define prec_max(prec,var) {if(mpfr_get_prec(var) > prec) prec = mpfr_get_prec(var); }
+#else
+#define prec_max(prec,var) {if(mpf_get_prec(var) > prec) prec = mpf_get_prec(var); }
+#endif
+
+#if defined(MPFR) && defined(HAVE_MPFR_H)
+#define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpfr_get_prec(c_var); }
+#define mpf_make_struct_init(ruby_var,c_var,prec) { mpf_make_struct(ruby_var,c_var); mpfr_init2 (c_var,prec); }
+#define mpf_temp_init(var,prec) { mpf_temp_alloc(var); mpfr_init2(var,prec); }
+#define mpf_temp_free(var) { mpfr_clear(var); free(var); }
+#define r_mpf_init(var1) (mpfr_init(var1))
+#define r_mpf_init2(var1, var2) (mpfr_init2(var1, var2))
+#define r_mpf_set_z(var1, var2) (mpfr_set_z(var1, var2, __gmp_default_rounding_mode))
+#define r_mpf_set_q(var1, var2) (mpfr_set_q(var1, var2, __gmp_default_rounding_mode))
+#define r_mpf_set_d(var1, var2) (mpfr_set_d(var1, var2, __gmp_default_rounding_mode))
+#define r_mpf_set_str(var1, var2, var3) (mpfr_set_str(var1, var2, var3, __gmp_default_rounding_mode))
+#define r_mpf_cmp(var1, var2) (mpfr_cmp(var1, var2))
+#else
+#define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpf_get_prec(c_var); }
+#define mpf_make_struct_init(ruby_var,c_var,prec) { mpf_make_struct(ruby_var,c_var); mpf_init2 (c_var,prec); }
 #define mpf_temp_init(var,prec) { mpf_temp_alloc(var); mpf_init2(var,prec); }
 #define mpf_temp_free(var) { mpf_clear(var); free(var); }
-#define prec_max(prec,var) {if(mpf_get_prec(var) > prec) prec = mpf_get_prec(var); }
+#define r_mpf_init(var1) (mpf_init(var1))
+#define r_mpf_init2(var1, var2) (mpf_init2(var1, var2))
+#define r_mpf_set_z(var1, var2) (mpf_set_z(var1, var2))
+#define r_mpf_set_q(var1, var2) (mpf_set_q(var1, var2))
+#define r_mpf_set_d(var1, var2) (mpf_set_d(var1, var2))
+#define r_mpf_set_str(var1, var2, var3) (mpf_set_str(var1, var2, var3))
+#define r_mpf_cmp(var1, var2) (mpf_cmp(var1, var2))
+#endif
+
+#if SIZEOF_INT < SIZEOF_LONG
+/* 64-bit */
+#define FIX2NUM(x) FIX2LONG(x)
+#else
+/* 32-bit */
+#define FIX2NUM(x) FIX2INT(x)
+#endif
 
 #define EXPECTED_ZQFXBD "Expected GMP::Z, GMP::Q, GMP::F, Fixnum, Bignum or Float"
 #define EXPECTED_ZQFXB "Expected GMP::Z, GMP::Q, GMP::F, Fixnum or Bignum"
+#define EXPECTED_ZFXBD "Expected GMP::Z, GMP::F, Fixnum, Bignum or Float"
 #define EXPECTED_ZXB "Expected GMP::Z, Fixnum or Bignum"
 #define EXPECTED_ZX "Expected GMP::Z or Fixnum"
 #define EXPECTED_X "Expected Fixnum"
@@ -201,15 +253,23 @@ extern VALUE r_gmpfsg_new(int argc, VALUE *argv, VALUE klass);
 extern VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self);
 extern void mpf_set_value(MP_FLOAT *self_val, VALUE arg);
 extern VALUE r_gmpmod_f(int argc, VALUE *argv, VALUE module);
+extern VALUE r_gmpf_get_prec(VALUE self);
+extern VALUE r_gmpf_set_prec(VALUE self, VALUE arg);
+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);
 
 // Float Arithmetic
+#ifndef MPFR
 extern VALUE r_gmpf_add(VALUE self, VALUE arg);
-extern VALUE r_gmpf_sub(VALUE self, VALUE arg);
 extern VALUE r_gmpf_mul(VALUE self, VALUE arg);
+#else
+extern VALUE r_gmpfr_add(int argc, VALUE *argv, VALUE self);
+extern VALUE r_gmpfr_mul(int argc, VALUE *argv, VALUE self);
+#endif
+extern VALUE r_gmpf_sub(VALUE self, VALUE arg);
 extern VALUE r_gmpf_div(VALUE self, VALUE arg);
 
 // Float Comparison
@@ -219,7 +279,11 @@ extern int mpf_cmp_value(MP_FLOAT *OP, VALUE arg);
 
 // MPFR
 #ifdef MPFR
+  extern void mpf_set_value2(MP_FLOAT *self_val, VALUE arg, int base);
+  
   extern VALUE r_gmpfr_sqrt(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_rec_sqrt(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_cbrt(int argc, VALUE *argv, VALUE self);
   
   extern VALUE r_gmpfr_log(int argc, VALUE *argv, VALUE self);
   extern VALUE r_gmpfr_log2(int argc, VALUE *argv, VALUE self);
@@ -256,6 +320,9 @@ extern int mpf_cmp_value(MP_FLOAT *OP, VALUE arg);
   extern VALUE r_gmpfr_gamma(int argc, VALUE *argv, VALUE self);
   extern VALUE r_gmpfr_lngamma(int argc, VALUE *argv, VALUE self);
   /*extern VALUE r_gmpfr_lgamma(int argc, VALUE *argv, VALUE self);*/
+#if MPFR_VERSION_MAJOR > 2
+  extern VALUE r_gmpfr_digamma(int argc, VALUE *argv, VALUE self);
+#endif
   extern VALUE r_gmpfr_zeta(int argc, VALUE *argv, VALUE self);
   extern VALUE r_gmpfr_erf(int argc, VALUE *argv, VALUE self);
   extern VALUE r_gmpfr_erfc(int argc, VALUE *argv, VALUE self);
@@ -275,7 +342,6 @@ extern int mpf_cmp_value(MP_FLOAT *OP, VALUE arg);
 
 // _unsorted_
 extern VALUE r_gmpf_sgn(VALUE self);
-extern VALUE r_gmpf_get_prec(VALUE self);
 
 
 /* from gmprandstate.h */

data/lib/gmp.rb

@@ -0,0 +1,9 @@
+# Thank you, Nokogiri
+
+require 'rbconfig'
+
+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'

data/manual.tex

@@ -20,7 +20,13 @@
 \def\qqqquad{\quad\quad\quad\quad}
 \def\cc{\colon\colon}
 \def\gmpz{\textit{GMP::Z}}
-\def\gmprandstate{\textit{GMP::RandState\ }}
+\def\gmpq{\textit{GMP::Q}}
+\def\gmpf{\textit{GMP::F}}
+\def\gmprandstate{\textit{GMP::RandState}}
+\def\gmpzs{\textit{GMP::Z}\ }
+\def\gmpqs{\textit{GMP::Q}\ }
+\def\gmpfs{\textit{GMP::F}\ }
+\def\gmprandstates{\textit{GMP::RandState\ }}
 \frenchspacing
 \begin{document}
 
@@ -28,8 +34,8 @@
 \huge{gmp} &\\
 \midrule[3pt]
 \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
-\multicolumn{2}{r}{\large{Edition 0.4.7}}\\
-\multicolumn{2}{r}{\large{25 March 2010}}
+\multicolumn{2}{r}{\large{Edition 0.5.3}}\\
+\multicolumn{2}{r}{\large{20 September 2010}}
 \end{tabular}
 
 \vfill
@@ -76,37 +82,59 @@ SPARCv7, SuperSPARC, generic SPARCv8, UltraSPARC, DEC VAX, and Zilog Z8000.
 Some optimizations also for Cray vector systems, Clipper, IBM ROMP (RT), and
 Pyramid AP/XP.\\
 \\
-For up-to-date information on GMP, please see the GMP web pages at\\
-\setlength{\parindent}{0.25in}
-\texttt{http://gmplib.org/}
-\setlength{\parindent}{0in}
-\\
+For up-to-date information on GMP, please see the GMP web pages at 
+\url{http://gmplib.org/}\\
 
-The latest version of the library is available at\\
-\setlength{\parindent}{0.25in}
-\texttt{ftp://ftp.gnu.org/gnu/gmp/}\\
-\setlength{\parindent}{0in}
-\\
+The latest version of the library is available at 
+\url{ftp://ftp.gnu.org/gnu/gmp/}\\
 
-Many sites around the world mirror '\texttt{ftp.gnu.org}', please use a mirror
-near you, see \texttt{http://www.gnu.org/order/ftp.html} for a full list.\\
+Many sites around the world mirror '\url{ftp.gnu.org}', please use a mirror
+near you, see \url{http://www.gnu.org/order/ftp.html} for a full list.\\
 \\
 There are three public mailing lists of interest. One for release
 announcements, one for general questions and discussions about usage of the GMP
-library, and one for bug reports. For more information, see\\
-\\
-\texttt{http://gmplib.org/mailman/listinfo/}.\\
-\\
+library, and one for bug reports. For more information, see 
+\url{http://gmplib.org/mailman/listinfo/}.\\
+
 The proper place for bug reports is gmp-bugs@gmplib.org. See Chapter 4
 [Reporting Bugs], page 28 for information about reporting bugs.
 
+\newpage
+\section{Introduction to MPFR}
+
+The gmp gem optionally interacts with the MPFR library as well. This entire page
+is copied verbatim from the MPFR manual.\\\\
+
+The MPFR library is a C library for multiple-precision floating-point
+computations with correct rounding. MPFR has continuously been supported by the
+INRIA and the current main authors come from the Caramel and Ar�naire
+project-teams at Loria (Nancy, France) and LIP (Lyon, France) respectively; see
+more on the credit page. MPFR is based on the GMP multiple-precision library.\\
+
+The main goal of MPFR is to provide a library for multiple-precision
+floating-point computation which is both efficient and has a well-defined
+semantics. It copies the good ideas from the ANSI/IEEE-754 standard for
+double-precision floating-point arithmetic (53-bit mantissa).\\
+
+MPFR is free. It is distributed under the GNU Lesser General Public License
+(GNU Lesser GPL), version 3 or later (2.1 or later for MPFR versions until
+2.4.x). The library has been registered in France by the Agence de Protection
+des Programmes under the number IDDN FR 001 120020 00 R P 2000 000 10800, on 15
+March 2000. This license guarantees your freedom to share and change MPFR, to
+make sure MPFR is free for all its users. Unlike the ordinary General Public
+License, the Lesser GPL enables developers of non-free programs to use MPFR in
+their programs. If you have written a new function for MPFR or improved an
+existing one, please share your work!
+
+\newpage
 \section{Introduction to the gmp gem}
 
 The gmp Ruby gem is a Ruby library that provides bindings to GMP. The gem is
 incomplete, and will likely only include a subset of the GMP functions. It is
-built as a C extension for ruby, interacting with gmp.h. The gmp gem is not
-endorsed or supported by GNU or the GMP team. The gmp gem also does not ship
-with GMP, so GMP must be compiled separately.
+built as a C extension for Ruby, interacting with gmp.h. The gmp gem is not
+endorsed or supported by GNU or the GMP team (or MPFR team). The gmp gem also
+does not ship with GMP (or MPFR), so GMP (and MPFR) must be compiled
+separately.
 
 \section{Installing the gmp gem}
 
@@ -117,6 +145,7 @@ of the following versions of Ruby:
   \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.
 \end{itemize}
 As you can see only Matz's Ruby Interpreter (MRI) is supported. I haven't even
 put a thought into trying other interpreters/VMs. I intend to look into FFI,
@@ -124,22 +153,53 @@ which supposedly will allow me to load this extension into JRuby and Rubinius,
 not sure about others...\\
 
 Next is the platform, the combination of the architecture (processor) and OS.
-As far as I can tell, if you can compile GMP and Ruby on a given platform, you
-can use the gmp gem there too. Please report problems with that hypothesis.\\
+As far as I can tell, if you can compile GMP and Ruby (and optionally MPFR) on
+a given platform, you can use the gmp gem there too. Please report problems
+with that hypothesis.\\
 
-Lastly, GMP. GMP must be compiled and working. "and working" means you ran "make
-check" while installing GMP. The following versions of GMP have been tested:
+Lastly, GMP (and MPFR). GMP (and MPFR) must be compiled and working. "And working" means
+you ran "make check" after compiling GMP (and MPFR), and it 'check's out. The following
+versions of GMP (and MPFR) have been tested:
 \begin{itemize}
-  \item GMP 4.3.1
-  \item GMP 4.3.2
-  \item GMP 5.0.0
-  \item GMP 5.0.1
+  \item GMP 4.3.1 (with MPFR 2.4.2)
+  \item GMP 4.3.2 (with MPFR 2.4.2 and 3.0.0)
+  \item GMP 5.0.0 (with MPFR 3.0.0)
+  \item GMP 5.0.1 (with MPFR 3.0.0)
 \end{itemize}
 
-That's all. I don't intend to test any older versions, maybe 4.3.0 for
-completeness.\\
+That's all. I don't intend to test any older versions.\\
 
-Here is a table of the exact environments on which I have tested the gmp gem:\\\\
+\newpage
+Here is a table of the exact environments on which I have tested the gmp gem.
+The (MPFR) version denotes that the gmp gem was tested both with and without
+the given version of MPFR:\\\\
+
+\begin{tabular}{lrrr} \hline
+             Platform                      &       Ruby       &    GMP    & (MPFR)  \\ \midrule[1pt]
+  Linux (Ubuntu NR 10.04) on x86 (32-bit)  & (MRI) Ruby 1.8.7 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.8.7 & GMP 5.0.1 & (3.0.0) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 5.0.1 & (3.0.0) \\
+                                           & (MRI) Ruby 1.9.2 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.2 & GMP 5.0.1 & (3.0.0) \\ \hline
+  Linux (Ubuntu 10.04) on x86\_64 (64-bit) & (MRI) Ruby 1.8.7 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.8.7 & GMP 5.0.1 & (3.0.0) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 5.0.1 & (3.0.0) \\
+                                           & (MRI) Ruby 1.9.2 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.2 & GMP 5.0.1 & (3.0.0) \\ \hline
+  Mac OS X 10.6.4 on x86\_64 (64-bit)      & (MRI) Ruby 1.8.7 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.8.7 & GMP 5.0.1 & (3.0.0) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 5.0.1 & (3.0.0) \\
+                                           & (MRI) Ruby 1.9.2 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.2 & GMP 5.0.1 & (3.0.0) \\ \hline
+  Windows XP on x86 (32-bit)               & (MRI) Ruby 1.9.1 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 5.0.1 & (3.0.0) \\ \hline
+\end{tabular}\\\\
+
+In addition, I \textit{used to test} on the following environments, in versions
+0.4.7 and earlier of the gmp gem:\\\\
 
 \begin{tabular}{lrr} \hline
              Platform             &       Ruby       &    GMP    \\ \midrule[1pt]
@@ -147,7 +207,6 @@ Here is a table of the exact environments on which I have tested the gmp gem:\\\
   Linux (LinuxMint 7) on x86      & (MRI) Ruby 1.8.7 & GMP 4.3.1 \\ \hline
   Mac OS X 10.5.7 on x86 (32-bit) & (MRI) Ruby 1.8.6 & GMP 4.3.1 \\ \hline
   Mac OS X 10.5.7 on x86 (32-bit) & (MRI) Ruby 1.9.1 & GMP 4.3.1 \\ \hline
-  Windows XP on x86 (32-bit)      & (MRI) Ruby 1.9.1 & GMP 5.0.1 \\ \hline
 \end{tabular}
 
 \subsection{Installing}
@@ -155,11 +214,12 @@ You may clone the gmp gem's git repository with:\\
 \\
 \texttt{git clone git://github.com/srawlins/gmp.git}\\
 
-Or you may install the gem from gemcutter:\\
+Or you may install the gem from gemcutter (rubygems.org):\\
 \\
 \texttt{gem install gmp}\\
 
-At this time, the gem does self-compiles. If required libraries cannot be found, you may
+\newpage
+At this time, the gem self-compiles. If required libraries cannot be found, you may
 compile the C extensions manually with:\\
 \\
 \texttt{cd <gmp gem directory>/ext}\\
@@ -177,7 +237,12 @@ You can run this test suite with:\\
 \texttt{ruby unit\_tests.rb}\\
 
 All tests should pass. If you don't have the test-unit gem installed, then you may
-run into one error.
+run into one error. It would look like:\\
+\\
+\texttt{  1) Error:}\\
+\texttt{test\_z\_div(TC\_division):}\\
+\texttt{TypeError: GMP::Q can't be coerced into Float}\\
+\texttt{    C:/Ruby191/devkit/msys/1.0.11/projects/gmp\_gem/test/tc\_division.rb:18:in `test\_z\_div'}\\
 
 \section{GMP and gmp gem basics}
 
@@ -219,6 +284,18 @@ There are additional constants within \texttt{GMP} when MPFR is linked:
     infinity."
   \item \texttt{GMP::GMP\_RNDD} - Rounding mode representing "round toward negative
     infinity."
+  \item \texttt{GMP::MPFR\_RNDN} - Rounding mode representing "round to nearest."\\
+    (MPFR version 3.0.0 or higher only)
+  \item \texttt{GMP::MPFR\_RNDZ} - Rounding mode representing "round toward zero."\\
+    (MPFR version 3.0.0 or higher only)
+  \item \texttt{GMP::MPFR\_RNDU} - Rounding mode representing "round toward positive
+    infinity."\\
+    (MPFR version 3.0.0 or higher only)
+  \item \texttt{GMP::MPFR\_RNDD} - Rounding mode representing "round toward negative
+    infinity."\\
+    (MPFR version 3.0.0 or higher only)
+  \item \texttt{GMP::MPFR\_RNDZ} - Rounding mode representing "round away from zero."\\
+    (MPFR version 3.0.0 or higher only)
 \end{itemize}
 
 \newpage
@@ -233,8 +310,8 @@ There are additional constants within \texttt{GMP} when MPFR is linked:
 & & GMP::Z.new(\textit{str}) $\rightarrow$ \textit{integer} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  This method creates a new \textit{GMP::Z} integer. It takes one optional argument for
-  the value of the integer. This argument can be one of several classes. Here are some
+  This method creates a new \gmpzs integer. It takes one optional argument for the value
+  of the integer. This argument can be one of several classes. Here are some
   examples:\newline
   
   \texttt{GMP::Z.new \qqqquad\qqqquad \#=> 0 (default) \newline
@@ -279,8 +356,8 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
   \textit{integer}.
   \newline
   
-  If \textit{integer} is too big to fit in a Fixnum, the returned result is probably not
-  very useful. To find out if the value will fit, use the function
+  If \textit{integer} is too big to fit in a \textit{Fixnum}, the returned result is
+  probably not very useful. To find out if the value will fit, use the function
   \textit{mpz\_fits\_slong\_p} (\textbf{Unimplemented}).
 }
 \end{tabular}
@@ -322,8 +399,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the sum of \textit{integer} and \textit{numeric}. \textit{numeric} can be an
-  instance of \textit{GMP::Z}, \textit{Fixnum}, \textit{GMP::Q}, \textit{GMP::F}, or
-  \textit{Bignum}.
+  instance of \gmpz, \textit{Fixnum}, \gmpq, \gmpf, or \textit{Bignum}.
 }
 \end{tabular}
 \newline\newline
@@ -335,8 +411,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Sums \textit{integer} and \textit{numeric}, in place. \textit{numeric} can be an
-  instance of \textit{GMP::Z}, \textit{Fixnum}, \textit{GMP::Q}, \textit{GMP::F}, or
-  \textit{Bignum}.
+  instance of \gmpz, \textit{Fixnum}, \gmpq, \gmpf, or \textit{Bignum}.
 }
 \end{tabular}
 \newline\newline
@@ -349,8 +424,8 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the difference of \textit{integer} and \textit{numeric}. The destructive method
   calculates the difference in place. \textit{numeric} can be an instance of
-  \textit{GMP::Z}, \textit{Fixnum}, \textit{GMP::Q}, \textit{GMP::F}, or \textit{Bignum}.
-  Here are some examples:\newline
+  \gmpz, \textit{Fixnum}, \gmpq, \gmpf, or \textit{Bignum}. Here are some
+  examples:\newline
   
   \texttt{seven     = GMP::Z(7) \newline
           nine \    = GMP::Z(9) \newline
@@ -376,7 +451,19 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the product of \textit{integer} and \textit{numeric}. The destructive method
   calculates the product in place. \textit{numeric} can be an instance of
-  \textit{GMP::Z}, \textit{Fixnum}, \textit{GMP::Q}, \textit{GMP::F}, or \textit{Bignum}.
+  \gmpz, \textit{Fixnum}, \gmpq, \gmpf, or \textit{Bignum}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{addmul!} & & \textit{integer}.addmul!(\textit{a}, \textit{b}) $\rightarrow$ \textit{numeric} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Sets \textit{integer} to the sum of \textit{integer} and the product of \textit{a} and
+  \textit{b}. This destructive method calculates the result in place. Both \textit{a} and
+  \textit{b} can be an instance of \gmpz, \textit{Fixnum}, or \textit{Bignum}.
 }
 \end{tabular}
 \newline\newline
@@ -424,7 +511,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the division of $integer$ by $numeric$, truncated. $numeric$ can be an instance
-  of $GMP::Z$, $Fixnum$, $Bignum$. The return object's class is always $GMP::Z$.
+  of \gmpz, $Fixnum$, $Bignum$. The return object's class is always \gmpz.
 }
 \end{tabular}
 \newline\newline
@@ -435,7 +522,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the division of $integer$ by $numeric$, floored. $numeric$ can be an instance
-  of $GMP::Z$, $Fixnum$, $Bignum$. The return object's class is always $GMP::Z$.
+  of \gmpz, $Fixnum$, $Bignum$. The return object's class is always \gmpz.
 }
 \end{tabular}
 \newline\newline
@@ -446,7 +533,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the ceiling division of $integer$ by $numeric$. $numeric$ can be an instance of
-  $GMP::Z$, $Fixnum$, $Bignum$. The return object's class is always $GMP::Z$.
+  \gmpz, $Fixnum$, $Bignum$. The return object's class is always \gmpz.
 }
 \end{tabular}
 \newline\newline
@@ -457,8 +544,8 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the remainder after truncated division of $integer$ by $numeric$. $numeric$ can
-  be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
-  $GMP::Z$.
+  be an instance of \gmpz, $Fixnum$, or $Bignum$. The return object's class is always
+  \gmpz.
 }
 \end{tabular}
 \newline\newline
@@ -469,8 +556,8 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the remainder after floored division of $integer$ by $numeric$. $numeric$ can
-  be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
-  $GMP::Z$.
+  be an instance of \gmpz, $Fixnum$, or $Bignum$. The return object's class is always
+  \gmpz.
 }
 \end{tabular}
 \newline\newline
@@ -481,8 +568,8 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the remainder after ceilinged division of $integer$ by $numeric$. $numeric$ can
-  be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
-  $GMP::Z$.
+  be an instance of \gmpz, $Fixnum$, or $Bignum$. The return object's class is always
+  \gmpz.
 }
 \end{tabular}
 \newline\newline
@@ -504,9 +591,11 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \toprule
 \textbf{**} & & \textit{integer} ** \textit{numeric} $\rightarrow$ \textit{numeric} \\
 & & \textit{integer}.pow(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
+& & GMP::Z.pow(\textit{integer}, \textit{numeric}) $\rightarrow$ \textit{numeric} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns $integer$ raised to the $numeric$ power.
+  Returns $integer$ raised to the $numeric$ power. In the singleton method (\textit{GMP::Z.pow()}),
+  \textit{integer} can be either a \gmpz, $Fixnum$, $Bignum$, or $String$.
 }
 \end{tabular}
 \newline\newline
@@ -814,7 +903,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \textbf{hash} & & $a$.hash $\rightarrow$ $string$ \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Used when comparing objects as Hash keys.
+  Used when comparing objects as $Hash$ keys.
 }
 \end{tabular}
 
@@ -967,6 +1056,18 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 }
 \end{tabular}
 
+\subsection{Integer Special Functions}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{size} & & $integer$.size $\rightarrow$ $fixnum$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the size of \textit{integer} measured in number of limbs. If \textit{integer}
+  is zero, then the returned value will be zero.
+}
+\end{tabular}
+
 \newpage
 \section{Rational Functions}
 
@@ -979,7 +1080,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 & & GMP::Q.new(\textit{str}) $\rightarrow$ \textit{rational} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  This method creates a new \textit{GMP::Q} rational number. It takes two optional
+  This method creates a new \gmpq rational number. It takes two optional
   arguments for the value of the numerator and denominator. These arguments can each be
   an instance of several classes. Here are some
   examples:\newline
@@ -1023,6 +1124,242 @@ There is also a convenience method available, \texttt{GMP::Q()}.\\
 }
 \end{tabular}
 
+\newpage
+\section{Floating-point Functions}
+
+\subsection{Initializing, Assigning Floats}
+
+\subsection{Floating-point Special Functions (MPFR Only)}
+
+Every method below accepts two additional parameters in addition to any required parameters. These are $rnd_mode$, the rounding mode to use in calculation, which defaults to \textit{GMP::GMP\_RNDN}, and $res_prec$, the precision of the result, which defaults to the \textit{f.prec}, the precision of $f$.\\
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{log}   & & $f$.log(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{log2}  & & $f$.log2(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{log10} & & $f$.log10(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the natural log, $\log_2$, and $\log_10$ of $f$, respectively. Returns $-Inf$ if $f$ is $-0$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{exp}   & & $f$.exp(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{exp2}  & & $f$.exp2(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{exp10} & & $f$.exp10(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the exponential of $f$, $2$ to the power of $f$, and $10$ to the power of $f$, respectively.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{cos} & & $f$.cos(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{sin} & & $f$.sin(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{tan} & & $f$.tan(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the cosine, sine, and tangent of $f$, respectively.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{sec} & & $f$.sec(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{csc} & & $f$.csc(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{cot} & & $f$.cot(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the secant, cosecant, and cotangent of $f$, respectively.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{acos} & & $f$.acos(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{asin} & & $f$.asin(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{atan} & & $f$.atan(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the arc-cosine, arc-sine, and arc-tangent of $f$, respectively.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{cosh} & & $f$.cosh(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{sinh} & & $f$.sinh(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{tanh} & & $f$.tanh(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the hyperbolic cosine, sine, and tangent of $f$, respectively.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{sech} & & $f$.sech(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{csch} & & $f$.csch(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{coth} & & $f$.coth(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the hyperbolic secant, cosecant, and cotangent of $f$, respectively.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{acosh} & & $f$.acosh(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{asinh} & & $f$.asinh(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{atanh} & & $f$.atanh(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the hyperbolic arc-cosine, arc-sine, and arc-tangent of $f$, respectively.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{log1p} & & $f$.log1p(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the logarithm of 1 plus $f$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{expm1} & & $f$.expm1(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the exponential of $f$ minus 1.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{eint} & & $f$.eint(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the exponential integral of $f$. For positive $f$, the exponential integral is
+  the sum of Euler's constant, of the logarithm of $f$, and of the sum for $k$ from $1$
+  to infinity of $f$ to the power $k$, divided by $k$ and factorial($k$). For negative
+  $f$, this method returns NaN.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{li2} & & $f$.li2(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the real part of the dilogarithm of $f$. MPFR defines the dilogarithm as the
+  integral of $-\log(1-t)/t$ from 0 to $f$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{gamma} & & $f$.gamma(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the value of the Gamma function on $f$. When $f$ is a negative integer, this
+  method returns NaN.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{lngamma} & & $f$.lngamma(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the value of the logarithm of the Gamma function on $f$. When
+  $-2k-1 \leq f \leq -2k$, $k$ being a non-negative integer, this method returns NaN.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{digamma} & & $f$.digamma(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the value of the Digamma (sometimes called Psi) function on $f$. When $f$ is
+  negative, this method returns NaN.\newline
+  \newline
+  Only available in MPFR version 3.0.0 or later.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{zeta} & & $f$.zeta(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the value of the Riemann Zeta function on $f$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{erf}  & & $f$.erf(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{erfc} & & $f$.erfc(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the value of the error function on $f$ (respectively the complementary error
+  function on $f$).
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{j0} & & $f$.j0(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{j1} & & $f$.j1(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{jn} & & $f$.jn(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the value of the first kind Bessel function of order $0$ (respectively $1$ and
+  $n$) on $f$. When $f$ is NaN, this method returns NaN. When $f$ is +Inf or -Inf, this
+  method returns $+0$. When $f$ is zero, this method returns +Inf or -Inf, depending on
+  the parity and sign of $n$, and the sign of $f$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{y0} & & $f$.y0(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{y1} & & $f$.y1(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\textbf{yn} & & $f$.yn(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the value of the second kind Bessel function of order $0$ (respectively $1$ and
+  $n$) on $f$. When $f$ is NaN or negative, this method returns NaN. When $f$ is +Inf,
+  this method returns $+0$. When $f$ is zero, this method returns +Inf or -Inf, depending
+  on the parity and sign of $n$.
+}
+\end{tabular}
+
+
 \newpage
 \section{Random Number Functions}
 
@@ -1093,4 +1430,101 @@ There is also a convenience method available, \texttt{GMP::Q()}.\\
 }
 \end{tabular}
 
+
+\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|}
+  \hline
+  GMP   & bench    & Ruby 1.8.7 & Ruby 1.9.1 & Ruby 1.9.2 & C \\
+  \hline
+  4.3.2 & multiply &  7696.5    &     7482.8 &     7608.2 & 16789   \\
+        & divide   &  7304.3    &     7148.0 &     7199.4 &  9872.5 \\
+        & gcd      &  2388.4    &     2412.1 &     2470.9 &  2938.9 \\
+        & rsa      &  2042.3    &     2058.0 &     2065.9 &  2136.7 \\
+  \hline
+  5.0.1 & multiply &  8142.6    &     7886.0 &     7952.7 & 17925   \\
+        & divide   & 10256      &    10088   &    10124   & 16069   \\
+        & gcd      &  2498.1    &     2547.0 &     2574.2 &  3063.7 \\
+        & rsa      &  2132.4    &     2157.4 &     2167.9 &  2229.2 \\
+  \hline
+\end{tabular}\\\\
+
+Ubuntu 10.04, Kernel 2.6.32-24, x86\_64 (64-bit)\\
+Ruby and GMP compiled with gcc 4.4.3 (Ubuntu 4.4.3-4ubuntu5)\\
+\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 &     7793.7 &     6825.7 &     7460.6 & 14716   \\
+        & divide   &     7687.6 &     7725.9 &     7473.3 &  8614.3 \\
+        & gcd      &     2450.1 &     2507.6 &     2476.6 &  2779.8 \\
+        & rsa      &     1979.1 &     2065.6 &     2059.2 &  1984.3 \\
+  \hline
+  5.0.1 & multiply &     9727.1 &     7020.3 &     7902.1 & 17695   \\
+        & divide   &     9306.4 &    10785   &    10799   & 15629   \\
+        & gcd      &     2345.3 &     2525.5 &     2541.2 &  2925.1 \\
+        & rsa      &     2116.5 &     2117.8 &     2143.9 &  2233.4 \\
+  \hline
+\end{tabular}\\\\
+
+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 & 3514.7  & 3649.4 & 3631.9 & 6448.7 \\
+        & divide   & 2996.7  & 3082.0 & 3065.2 & 3717.5 \\
+        & gcd      & 1142.8  & 1183.3 & 1203.6 & 1359.4 \\
+        & rsa      & 719.41  & 730.05 & 736.03 & 757.97 \\
+  \hline
+  5.0.1 & multiply & 3702.9  & 3824.1 & 3763.8 & 6835.2 \\
+        & divide   & 4549.7  & 4600.9 & 4609.2 & 6497.4 \\
+        & gcd      & 1204.9  & 1233.4 & 1235.0 & 1394.2 \\
+        & rsa      & 729.68  & 735.13 & 728.56 & 754.72 \\
+  \hline
+\end{tabular}\\
+
 \end{document}