gmp 0.4.3-x86-mingw32 → 0.4.7-x86-mingw32

data/ext/mprnd.c

@@ -0,0 +1,77 @@
+#include <mprnd.h>
+
+#ifdef MPFR
+
+VALUE r_mprnd_initialize(int argc, VALUE *argv, VALUE self);
+
+VALUE r_mprndsg_new(int argc, VALUE *argv, VALUE klass)
+{
+  VALUE res;
+  int *res_value;
+  (void)klass;
+  res_value = 0;
+  
+  mprnd_make_struct(res, res_value);
+  rb_obj_call_init(res, argc, argv);
+  return res;
+}
+
+VALUE r_mprnd_initialize(int argc, VALUE *argv, VALUE self)
+{
+  VALUE mode, name, ieee754;
+  mode = argv[0];
+  (void)argc;
+  switch (FIX2INT(mode)) {
+  case 0:
+    name = rb_str_new2("GMP_RNDN");
+    ieee754 = rb_str_new2("roundTiesToEven");
+    break;
+  case 1:
+    name = rb_str_new2("GMP_RNDZ");
+    ieee754 = rb_str_new2("roundTowardZero");
+    break;
+  case 2:
+    name = rb_str_new2("GMP_RNDU");
+    ieee754 = rb_str_new2("roundTowardPositive");
+    break;
+  case 3:
+    name = rb_str_new2("GMP_RNDD");
+    ieee754 = rb_str_new2("roundTowardNegative");
+    break;
+  default:
+    name = rb_str_new2("GMP_RNDN");
+    ieee754 = rb_str_new2("roundTiesToEven");
+  }
+  rb_iv_set(self, "@mode",    mode);
+  rb_iv_set(self, "@name", name);
+  rb_iv_set(self, "@ieee754", ieee754);
+  return Qnil;
+}
+
+VALUE r_mprnd_inspect(VALUE self)
+{
+  return rb_iv_get(self, "@name");
+}
+
+void init_gmprnd()
+{
+  mGMP = rb_define_module("GMP");
+  ID new_id = rb_intern("new");
+
+  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)));
+  rb_define_const(mGMP, "GMP_RNDD", rb_funcall (cGMP_Rnd, new_id, 1, INT2FIX(3)));
+}
+
+#endif /* MPFR */

data/ext/mprnd.h

@@ -0,0 +1,12 @@
+#ifndef _MPRND_H_
+#define _MPRND_H_
+
+/*
+ * mprnd.h
+ *
+ * This file contains GMP::Z method definitions.
+ */
+
+#include <ruby_gmp.h>
+
+#endif

data/ext/ruby_gmp.h

@@ -82,7 +82,16 @@ typedef __gmp_randstate_struct MP_RANDSTATE;
 //should change exception type
 #define not_yet rb_raise(rb_eTypeError,"Not implemented yet")
 
+#ifdef MPFR
+#define mprnd_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, int, c_var); }
+#define mprnd_make_struct(ruby_var,c_var) { ruby_var = Data_Make_Struct(cGMP_Rnd, int, 0, 0, c_var); }
+#define GMPRND_P(value)   (rb_obj_is_instance_of(value, cGMP_Rnd) == Qtrue)
+#endif /* MPFR */
+
 extern VALUE mGMP, cGMP_Z, cGMP_Q, cGMP_F, cGMP_RandState;
+#ifdef MPFR
+extern VALUE cGMP_Rnd;
+#endif /* MPFR */
 
 extern void r_gmpz_free(void *ptr);
 extern void r_gmpq_free(void *ptr);
@@ -110,12 +119,16 @@ extern VALUE r_gmpz_add_self(VALUE self, VALUE arg);
 extern VALUE r_gmpz_sub(VALUE self, VALUE arg);
 extern VALUE r_gmpz_sub_self(VALUE self, VALUE arg);
 extern VALUE r_gmpz_mul(VALUE self, VALUE arg);
+extern VALUE r_gmpz_div(VALUE self, VALUE arg);
 
 // Integer Division
 extern VALUE r_gmpz_mod(VALUE self, VALUE arg);
 
 // Integer Exponentiation
 extern VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp);
+extern VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod);
+
+// Integer Roots
 
 // Number Theoretic Functions
 extern VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self);
@@ -130,22 +143,19 @@ extern VALUE r_gmpz_remove(VALUE self, VALUE arg);
 extern VALUE r_gmpz_eq(VALUE self, VALUE arg);
 extern VALUE r_gmpz_cmp(VALUE self, VALUE arg);
 extern VALUE r_gmpz_cmpabs(VALUE self, VALUE arg);
+extern VALUE r_gmpz_sgn(VALUE self);
+extern int mpz_cmp_value(MP_INT *OP, VALUE arg);
 
-// Miscelaneous Integer Functions
-extern VALUE r_gmpz_sizeinbase(VALUE self, VALUE base);
-extern VALUE r_gmpz_size_in_bin(VALUE self);
-
-// _unsorted_
-extern VALUE r_gmpz_div(VALUE self, VALUE arg);
+// Integer Logic and Bit Fiddling
 extern VALUE r_gmpz_popcount(VALUE self);
-extern VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to);
-extern VALUE r_gmpz_getbit(VALUE self, VALUE bitnr);
 extern VALUE r_gmpz_scan0(VALUE self, VALUE bitnr);
 extern VALUE r_gmpz_scan1(VALUE self, VALUE bitnr);
-extern VALUE r_gmpz_powm(VALUE self, VALUE exp, VALUE mod);
-extern VALUE r_gmpz_sgn(VALUE self);
-extern int mpz_cmp_value(MP_INT *OP, VALUE arg);
+extern VALUE r_gmpz_setbit(VALUE self, VALUE bitnr, VALUE set_to);
+extern VALUE r_gmpz_getbit(VALUE self, VALUE bitnr);
 
+// Miscelaneous Integer Functions
+extern VALUE r_gmpz_sizeinbase(VALUE self, VALUE base);
+extern VALUE r_gmpz_size_in_bin(VALUE self);
 
 
 /* from gmpq.h */
@@ -209,36 +219,58 @@ extern int mpf_cmp_value(MP_FLOAT *OP, VALUE arg);
 
 // MPFR
 #ifdef MPFR
-  extern VALUE r_gmpfr_sqrt(VALUE self);
+  extern VALUE r_gmpfr_sqrt(int argc, VALUE *argv, VALUE self);
   
-  extern VALUE r_gmpfr_log(VALUE self);
-  extern VALUE r_gmpfr_log2(VALUE self);
-  extern VALUE r_gmpfr_log10(VALUE self);
-  extern VALUE r_gmpfr_exp(VALUE self);
+  extern VALUE r_gmpfr_log(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_log2(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_log10(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_exp(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_exp2(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_exp10(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_cos(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_sin(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_tan(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_sec(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_csc(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_cot(int argc, VALUE *argv, VALUE self);
   
-  extern VALUE r_gmpfr_cos(VALUE self);
-  extern VALUE r_gmpfr_sin(VALUE self);
-  extern VALUE r_gmpfr_tan(VALUE self);
-  extern VALUE r_gmpfr_sec(VALUE self);
-  extern VALUE r_gmpfr_csc(VALUE self);
-  extern VALUE r_gmpfr_cot(VALUE self);
+  extern VALUE r_gmpfr_acos(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_asin(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_atan(int argc, VALUE *argv, VALUE self);
   
-  extern VALUE r_gmpfr_acos(VALUE self);
-  extern VALUE r_gmpfr_asin(VALUE self);
-  extern VALUE r_gmpfr_atan(VALUE self);
+  extern VALUE r_gmpfr_cosh(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_sinh(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_tanh(int argc, VALUE *argv, VALUE self);
   
-  extern VALUE r_gmpfr_cosh(VALUE self);
-  extern VALUE r_gmpfr_sinh(VALUE self);
-  extern VALUE r_gmpfr_tanh(VALUE self);
+  extern VALUE r_gmpfr_sech(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_csch(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_coth(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_acosh(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_asinh(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_atanh(int argc, VALUE *argv, VALUE self);
   
-  extern VALUE r_gmpfr_acosh(VALUE self);
-  extern VALUE r_gmpfr_asinh(VALUE self);
-  extern VALUE r_gmpfr_atanh(VALUE self);
+  extern VALUE r_gmpfr_log1p(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_expm1(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_eint(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_li2(int argc, VALUE *argv, VALUE self);
+  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);*/
+  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);
+  extern VALUE r_gmpfr_j0(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_j1(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_jn(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_y0(int argc, VALUE *argv, VALUE self);
+  extern VALUE r_gmpfr_y1(int argc, VALUE *argv, VALUE self);
   
   extern VALUE r_gmpfrsg_const_log2();
   extern VALUE r_gmpfrsg_const_pi();
   extern VALUE r_gmpfrsg_const_euler();
   extern VALUE r_gmpfrsg_const_catalan();
+  
+  extern mp_rnd_t r_get_rounding_mode(VALUE rnd);
 #endif /* MPFR */
 
 // _unsorted_
@@ -279,5 +311,8 @@ extern void init_gmpq();
 extern void init_gmpf();
 extern void init_gmprandstate();
 extern void init_gmpbench_timing();
+#ifdef MPFR
+extern void init_gmprnd();
+#endif /* MPFR */
 
 #endif

data/manual.tex

@@ -28,8 +28,8 @@
 \huge{gmp} &\\
 \midrule[3pt]
 \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
-\multicolumn{2}{r}{\large{Edition 0.4.3}}\\
-\multicolumn{2}{r}{\large{8 March 2010}}
+\multicolumn{2}{r}{\large{Edition 0.4.7}}\\
+\multicolumn{2}{r}{\large{25 March 2010}}
 \end{tabular}
 
 \vfill
@@ -159,12 +159,8 @@ Or you may install the gem from gemcutter:\\
 \\
 \texttt{gem install gmp}\\
 
-Or you may install the gem from github (old):\\
-\\
-\texttt{gem install srawlins-gmp}\\
-
-At this time, the gem does not self-compile (how does that work?). To compile the C
-extensions, do the following:\\
+At this time, the gem does self-compiles. If required libraries cannot be found, you may
+compile the C extensions manually with:\\
 \\
 \texttt{cd <gmp gem directory>/ext}\\
 \texttt{ruby extconf.rb}\\
@@ -181,16 +177,15 @@ 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. I'm not sure why this is... I suspect a bug in Ruby's Test::Unit
-that the test-unit gem monkey patches.
+run into one error.
 
 \section{GMP and gmp gem basics}
 
 \subsection{Classes}
 The gmp gem includes the namespace \texttt{GMP} and four classes within \texttt{GMP}:
 \begin{itemize}
-  \item \texttt{GMP::Z} - Methods for signed integer arithmetic. There are at least 45
-    methods here (still accounting).
+  \item \texttt{GMP::Z} - Methods for signed integer arithmetic. There are about 64
+    methods here.
   \item \texttt{GMP::Q} - Methods for rational number arithmetic. There are at least 11
     methods here (still accounting).
   \item \texttt{GMP::F} - Methods for floating-point arithmetic. There are at least 6
@@ -199,7 +194,7 @@ The gmp gem includes the namespace \texttt{GMP} and four classes within \texttt{
     methods here.
 \end{itemize}
 
-In addition to the above four classes, there is also one constant within \texttt{GMP}:
+In addition to the above four classes, there are also four constants within \texttt{GMP}:
 \begin{itemize}
   \item \texttt{GMP::GMP\_VERSION} - The version of GMP linked into the gmp gem
   \item \texttt{GMP::GMP\_CC} - The compiler that compiled GMP linked into the gmp gem
@@ -502,6 +497,31 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 }
 \end{tabular}
 
+\newpage
+\subsection{Integer Exponentiation}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{**} & & \textit{integer} ** \textit{numeric} $\rightarrow$ \textit{numeric} \\
+& & \textit{integer}.pow(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns $integer$ raised to the $numeric$ power.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{powmod} & & \textit{integer}.powmod(\textit{exp}, \textit{mod}) $\rightarrow$ \textit{integer} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns $integer$ raised to the $exp$ power, modulo $mod$. Negative $exp$ is supported
+  if an inverse, $integer^{-1}$ modulo $mod$, exists. If an inverse doesn't exist then a
+  divide by zero exception is raised.
+}
+\end{tabular}
+
 \subsection{Integer Roots}
 
 \begin{tabular}{p{\methwidth} l r}
@@ -517,7 +537,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \begin{tabular}{p{\methwidth} l r}
 \toprule
 \textbf{sqrt} & & \textit{integer}.sqrt $\rightarrow$ \textit{numeric} \\
-& & \textit{integer}.sqrt!(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
+& & \textit{integer}.sqrt! $\rightarrow$ \textit{numeric} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Returns the truncated integer part of the square root of $integer$.
@@ -562,30 +582,6 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 }
 \end{tabular}
 
-\subsection{Integer Exponentiation}
-
-\begin{tabular}{p{\methwidth} l r}
-\toprule
-\textbf{**} & & \textit{integer} ** \textit{numeric} $\rightarrow$ \textit{numeric} \\
-& & \textit{integer}.pow(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
-\cmidrule(r){2-3}
-& \multicolumn{2}{p{\defnwidth}}{
-  Returns $integer$ raised to the $numeric$ power.
-}
-\end{tabular}
-\newline\newline
-
-\begin{tabular}{p{\methwidth} l r}
-\toprule
-\textbf{powmod} & & \textit{integer}.powmod(\textit{exp}, \textit{mod}) $\rightarrow$ \textit{integer} \\
-\cmidrule(r){2-3}
-& \multicolumn{2}{p{\defnwidth}}{
-  Returns $integer$ raised to the $exp$ power, modulo $mod$. Negative $exp$ is supported
-  if an inverse, $integer^{-1}$ modulo $mod$, exists. If an inverse doesn't exist then a
-  divide by zero exception is raised.
-}
-\end{tabular}
-
 \subsection{Number Theoretic Functions}
 
 \begin{tabular}{p{\methwidth} l r}
@@ -715,6 +711,113 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 }
 \end{tabular}
 
+\subsection{Integer Comparisons}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{\textless=\textgreater} & & $a$ \textless=\textgreater\ $b$ $\rightarrow$ $fixnum$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns a negative Fixnum if $a$ is less than $b$.\newline
+  Returns 0 if $a$ is equal to $b$.\newline
+  Returns a positive Fixnum if $a$ is greater than $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{\textless} & & $a$ \textless\ $b$ $\rightarrow$ $boolean$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns true if $a$ is less than $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{\textless=} & & $a$ \textless=\ $b$ $\rightarrow$ $boolean$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns true if $a$ is less than or equal to $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{==} & & $a$ == $b$ $\rightarrow$ $boolean$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns true if $a$ is equal to $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{\textgreater=} & & $a$ \textgreater= $b$ $\rightarrow$ $boolean$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns true if $a$ is greater than or equal to $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{\textgreater} & & $a$ \textgreater\ $b$ $\rightarrow$ $boolean$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns true if $a$ is greater than $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{cmpabs} & & $a$.cmpabs($b$) $\rightarrow$ $fixnum$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns a negative Fixnum if abs($a$) is less than abs($b$).\newline
+  Returns 0 if abs($a$) is equal to abs($b$).\newline
+  Returns a positive Fixnum if abs($a$) is greater than abs($b$).
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{sgn} & & $a$.sgn $\rightarrow$ $-1$, $0$, or $1$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns -1 if $a$ is less than $b$.\newline
+  Returns 0 if $a$ is equal to $b$.\newline
+  Returns 1 if $a$ is greater than $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{eql?} & & $a$.eql?($b$) $\rightarrow$ $boolean$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Used when comparing objects as Hash keys.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{hash} & & $a$.hash $\rightarrow$ $string$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Used when comparing objects as Hash keys.
+}
+\end{tabular}
+
 \subsection{Integer Logic and Bit Fiddling}
 
 \begin{tabular}{p{\methwidth} l r}
@@ -747,6 +850,30 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \end{tabular}
 \newline\newline
 
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{com} & & $integer$.com $\rightarrow$ $complement$ \\
+& & $integer$.com! $\rightarrow$ $complement$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the one's complement of $integer$. The destructive method sets $integer$ to
+  the one's complement of $integer$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{popcount} & & $n$.popcount $\rightarrow$ $fixnum$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  If $n>=0$, return the population count of $n$, which is the number of 1 bits in the
+  binary representation. If $n<0$, the number of 1s is infinite, and the return value
+  is the largest possible $mp\_bitcnt\_t$. 
+}
+\end{tabular}
+\newline\newline
+
 \begin{tabular}{p{\methwidth} l r}
 \toprule
 \textbf{scan0} & & $n$.scan0($i$) $\rightarrow$ $integer$ \\
@@ -761,6 +888,84 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
   scan0 past the end of a negative number.
 }
 \end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{scan1} & & $n$.scan1($i$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Scans $n$, starting from bit $i$, towards more significant bits, until the first 1 bit
+  is found. Return the index of the found bit.
+  \newline\newline
+  If the bit at $i$ is already what's sought, then $i$ is returned.
+  \newline\newline
+  If there's no bit found, then $INT2FIX(ULONG\_MAX)$ is returned. This will happen in
+  scan1 past the end of a negative number.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{[]} & & $n$[$bit\_index$] $\rightarrow$ $0$ or $1$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Tests bit $bit\_index$ in $n$ and return $0$ or $1$ accordingly.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{[]=} & & $n$[$bit\_index$]=$i$ $\rightarrow$ $nil$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Sets bit $bit\_index$ in $n$ to $i$.
+}
+\end{tabular}
+
+\newpage
+\subsection{Miscellaneous Integer Functions}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{odd?} & & $n$.odd? $\rightarrow$ $boolean$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns whether $n$ is odd.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{even?} & & $n$.even? $\rightarrow$ $boolean$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns whether $n$ is even.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{sizeinbase} & & $n$.sizeinbase($b$) $\rightarrow$ $digits$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the number of digits in base $b$. $b$ can vary between 2 and 62.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{size\_in\_bin} & & $n$.size\_in\_bin $\rightarrow$ $digits$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the number of digits in $n$'s binary representation.
+}
+\end{tabular}
 
 \newpage
 \section{Rational Functions}
@@ -781,7 +986,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
   
   \texttt{GMP::Q.new \qqqquad\qqqquad \#=> 0 (default) \newline
           GMP::Q.new(1) \qqqquad\qquad\  \#=> 1 (Ruby Fixnum) \newline
-          GMP::Q.new(1,3) \qqqquad\  \#=> 1/3 (Ruby Fixnums) \newline
+          GMP::Q.new(1,3) \qqqquad\quad\  \#=> 1/3 (Ruby Fixnums) \newline
           GMP::Q.new("127") \qqqquad\  \#=> 127 (Ruby String)\newline
           GMP::Q.new(4294967296) \qquad \#=> 4294967296 (Ruby Bignum)\newline
           GMP::Q.new(GMP::Z.new(31))  \#=> 31 (GMP Integer)}
@@ -791,6 +996,33 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 
 There is also a convenience method available, \texttt{GMP::Q()}.\\
 
+\subsection{Converting Rationals}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{to\_d} & & \textit{rational}.to\_d $\rightarrow$ \textit{float} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns \textit{rational} as an Float if \textit{rational} fits in a Float.
+
+  Otherwise returns the least significant part of \texttt{rational}, with the same sign as
+  \textit{rational}.
+  
+  If \textit{rational} is too big to fit in a Float, the returned result is probably not
+  very useful.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{to\_s} & & \textit{rational}.to\_s $\rightarrow$ \textit{str} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Converts \textit{rational} to a string.
+}
+\end{tabular}
+
 \newpage
 \section{Random Number Functions}