gmp 0.2.2 → 0.4.0

data/manual.tex

@@ -19,6 +19,8 @@
 \def\qquad{\quad\quad}
 \def\qqqquad{\quad\quad\quad\quad}
 \def\cc{\colon\colon}
+\def\gmpz{\textit{GMP::Z}}
+\def\gmprandstate{\textit{GMP::RandState\ }}
 \frenchspacing
 \begin{document}
 
@@ -26,8 +28,8 @@
 \huge{gmp} &\\
 \midrule[3pt]
 \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
-\multicolumn{2}{r}{\large{Edition 0.2.2}}\\
-\multicolumn{2}{r}{\large{21 December 2009}}
+\multicolumn{2}{r}{\large{Edition 0.4.0}}\\
+\multicolumn{2}{r}{\large{26 February 2010}}
 \end{tabular}
 
 \vfill
@@ -37,7 +39,7 @@
 
 \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.\\
+the GNU multiple precision arithmetic library, version 4.3.x or 5.0.x.\\
 \\
 Copyright 2009 Sam Rawlins.\\
 No license yet.
@@ -114,8 +116,7 @@ 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 - more of a "release candidate" state. Please report
-    bugs.
+  \item (MRI) Ruby 1.9.1 - 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,
@@ -126,14 +127,19 @@ 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.\\
 
-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. GMP must be compiled and working. "and working" means you ran "make
+check" while installing GMP. The following versions of GMP 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
 \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, maybe 4.3.0 for
+completeness.\\
 
-Here is a table of the exact environments I have tested the gmp gem on:\\\\
+Here is a table of the exact environments on which I have tested the gmp gem:\\\\
 
 \begin{tabular}{lrr} \hline
              Platform             &       Ruby       &    GMP    \\ \midrule[1pt]
@@ -141,6 +147,7 @@ Here is a table of the exact environments I have tested the gmp gem on:\\\\
   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}
@@ -148,23 +155,39 @@ 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 github:\\
+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:\\
 \\
-\texttt{cd <srawlins-gmp gem directory>/ext}\\
+\texttt{cd <gmp gem directory>/ext}\\
 \texttt{ruby extconf.rb}\\
 \texttt{make}\\
 
 There shouldn't be any errors, or warnings.
 
+\section{Testing the gmp gem}
+
+Testing the gmp gem is quite simple. The test/unit\_tests.rb suite uses Unit::Test.
+You can run this test suite with:\\
+\\
+\texttt{cd <gmp gem directory>/test}\\
+\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.
+
 \section{GMP and gmp gem basics}
 
 \subsection{Classes}
-The gmp gem includes the namespace \texttt{GMP} and three classes within \texttt{GMP}:
+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).
@@ -172,9 +195,11 @@ The gmp gem includes the namespace \texttt{GMP} and three classes within \texttt
     methods here (still accounting).
   \item \texttt{GMP::F} - Methods for floating-point arithmetic. There are at least 6
     methods here (still accounting).
+  \item \texttt{GMP::RandState} - Methods for random number generation. There are 3
+    methods here.
 \end{itemize}
 
-In addition to the above three classes, there is also one constant within \texttt{GMP}:
+In addition to the above four classes, there is also one constant within \texttt{GMP}:
 \begin{itemize}
   \item \texttt{GMP::GMP\_VERSION} - The version of GMP compiled into the gmp gem.
 \end{itemize}
@@ -415,7 +440,7 @@ 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$, $Bignum$. The return object's class is always
+  be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
   $GMP::Z$.
 }
 \end{tabular}
@@ -427,7 +452,7 @@ 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$, $Bignum$. The return object's class is always
+  be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
   $GMP::Z$.
 }
 \end{tabular}
@@ -439,10 +464,21 @@ 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$, $Bignum$. The return object's class is always
+  be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
   $GMP::Z$.
 }
 \end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{\%} & & \textit{integer} \% \textit{numeric} $\rightarrow$ \textit{integer}\\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns $integer$ modulo $numeric$. $numeric$ can be an instance of \gmpz, $Fixnum$,
+  or $Bignum$. The return object's class is always \gmpz.
+}
+\end{tabular}
 
 \subsection{Integer Roots}
 
@@ -568,6 +604,36 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \end{tabular}
 \newline\newline
 
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{gcd} & & $a$.gcd($b$) $\rightarrow$ $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Computes the greatest common divisor of $a$ and $b$. $g$ will always be positive, even
+  if $a$ or $b$ is negative. $b$ can be an instance of \gmpz, $Fixnum$, or $Bignum$.
+  \newline\newline
+  \texttt{GMP::Z(24).gcd(GMP::Z(8)) \quad \#=> GMP::Z(8) \newline
+          GMP::Z(24).gcd(8) \quad \#=> GMP::Z(8) \newline
+          GMP::Z(24).gcd(2**32) \quad \#=> GMP::Z(8)}
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{invert} & & $a$.invert($m$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Computes the inverse of $a$ mod $m$. $m$ can be an instance of \gmpz, $Fixnum$, or
+  $Bignum$.
+  \newline\newline
+  \texttt{GMP::Z(2).invert(GMP::Z(11)) \quad \#=> GMP::Z(6) \newline
+          GMP::Z(3).invert(11) \quad \#=> GMP::Z(4) \newline
+          GMP::Z(5).invert(11) \quad \#=> GMP::Z(9)}
+}
+\end{tabular}
+\newline\newline
+
 \begin{tabular}{p{\methwidth} l r}
 \toprule
 \textbf{jacobi} & & $a$.jacobi($b$) $\rightarrow$ $integer$ \\
@@ -577,10 +643,10 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
   Returns the Jacobi symbol $(a/b)$. This is defined only for $b$ odd. If $b$ is even, a
   range exception will be raised.
   \newline\newline
-  $GMP::Z.jacobi$ (the instance method) requires $b$ to be an instance of $GMP::Z$.
+  \textit{GMP::Z.jacobi} (the instance method) requires $b$ to be an instance of \gmpz.
   \newline
-  $GMP::Z\#jacobi$ (the class method) requires $a$ and $b$ each to be an instance of
-  $GMP::Z$, $Fixnum$, or $Bignum$.
+  \textit{GMP::Z\#jacobi} (the class method) requires $a$ and $b$ each to be an instance of
+  \gmpz, $Fixnum$, or $Bignum$.
 }
 \end{tabular}
 \newline\newline
@@ -602,8 +668,136 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Remove all occurrences of the factor $factor$ from $n$. $factor$ can be an instance of
-  $GMP::Z$, $Fixnum$, or $Bignum$. $integer$ is the resulting integer, an instance of
-  $GMP::Z$. $times$ is how many times $factor$ was removed, a $Fixnum$.
+  \gmpz, $Fixnum$, or $Bignum$. $integer$ is the resulting integer, an instance of
+  \gmpz. $times$ is how many times $factor$ was removed, a $Fixnum$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{fac} & & GMP::Z.fac($n$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns $n!$, or, $n$ factorial.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\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.
+}
+\end{tabular}
+
+
+
+\subsection{Integer Logic and Bit Fiddling}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{and} & & $a$ \& $b$ $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns $integer$, the bitwise and of $a$ and $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{ior} & & $a$ \textbar\ $b$ $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns $integer$, the bitwise inclusive or of $a$ and $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{xor} & & $a$ \textasciicircum\ $b$ $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns $integer$, the bitwise exclusive or of $a$ and $b$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{scan0} & & $n$.scan0($i$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Scans $n$, starting from bit $i$, towards more significant bits, until the first 0 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
+  scan0 past the end of a negative number.
+}
+\end{tabular}
+
+\newpage
+\section{Random Number Functions}
+
+\subsection{Random State Initialization}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{new} & & GMP::RandState.new $\rightarrow$ \textit{mersenne twister state} \\
+& & GMP::RandState.new(:default) $\rightarrow$ \textit{mersenne twister state} \\
+& & GMP::RandState(:mt) $\rightarrow$ \textit{mersenne twister random state} \\
+& & GMP::RandState.new(:lc\_2exp, a, c, m2exp) $\rightarrow$ \textit{linear congruential state} \\
+& & GMP::RandState.new(:lc\_2exp\_size, size) $\rightarrow$ \textit{linear congruential state} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  This method creates a new \gmprandstate instance. The first argument defaults
+  to \textit{:default} (also \textit{:mt}), which initializes the \gmprandstate for a Mersenne
+  Twister algorithm. No other arguments should be given if \textit{:default} or \textit{:mt} is
+  specified.
+  \newline\newline
+  If the first argument given is \textit{:lc\_2exp}, then the \gmprandstate is
+  initialized for a linear congruential algorithm. \textit{:lc\_2exp} must be followed with $a$,
+  $c$, and $m2exp$. The algorithm can then proceed as ($X = (a*X + c) \mod 2^{m2exp}$).
+  \newline\newline
+  \gmprandstate can also be initialized for a linear congruential algorithm with
+  \textit{:lc\_2exp\_size}. This initializer instead takes just one argument, $size$. $a$, $c$,
+  and $m2exp$ are then chosen from a table, with $m2exp/2 > size$. The maximum size
+  currently supported is 128.\newline
+  
+  \texttt{GMP::RandState.new \newline
+          GMP::RandState.new(:mt) \newline
+          GMP::RandState.new(:lc\_2exp, 1103515245, 12345, 15) \quad \#=> Perl's old rand() \newline
+          GMP::RandState.new(:lc\_2exp, 25\_214\_903\_917, 11, 48) \quad \#=> drand48}
+}
+\end{tabular}
+
+\subsection{Random State Seeding}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{seed} & & $state$.seed($integer$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Set an initial seed value into $state$. $integer$ can be an instance of \gmpz,
+  $Fixnum$, or $Bignum$.
+}
+\end{tabular}
+
+\subsection{Integer Random Numbers}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{urandomb} & & $state$.urandomb($n$) $\rightarrow$ $n$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Generates a uniformly distributed random integer in the range $0$ to $2^n -1$,
+  inclusive.
 }
 \end{tabular}
 

data/test/README

@@ -1,10 +1,3 @@
-TODO: Port everything to Test::Unit framework
-Test files 1-6 ported.
-
-Current version passes:
-  1-23
-Current version fails on these tests because:
-  none
 Tests:
    1*   initializations and to_s
    2*   basic integer arithmetics and coersion to Z
@@ -24,18 +17,18 @@ Tests:
   16*   floating point init with and without explicit precision
   17*   basic floating point arithmetics and coersion to F
   18*   default_prec and default_prec=
-  19    integer division methods
+  19*   integer division methods
   20    mpfr - exp and log
   21    mpfr - trigonometry
   22    mpfr - type tests
   23    mpfr - sqrt and power
-  24    jacobi, legendre, remove
+  24*   jacobi, legendre, remove
+  25*   gcd, gcdext, lcm, invert
 TODO:
   gcd, lcm
   cmpabs
   integer and integer->rational division, modulo
   more number theoretic functions
   random numbers
-  range error exceptions
+  range errors
   full coverage?
-  use more assert_in_delta

data/test/tc_division.rb

@@ -0,0 +1,109 @@
+require 'test_helper'
+
+class TC_division < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z.new(5)
+    @b = GMP::Z.new(7)
+    @c = GMP::Z.new(25)
+    @d = GMP::Q.new(3,11)
+    @e = GMP::F.new(3.14)
+    @f = 2**32
+  end
+  
+  def test_z_div
+    assert_equal(GMP::Q, (@a / @b   ).class, "GMP::Z / GMP::Z should be GMP::Q.")
+    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.")
+    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.")
+  end
+  
+  def test_z_tdiv
+    assert_equal(GMP::Z, @a.tdiv(@b).class,    "GMP::Z.tdiv GMP::Z should be GMP::Z.")
+    assert_equal(GMP::Z, @a.tdiv(3).class,     "GMP::Z.tdiv Fixnum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.tdiv(2**32).class, "GMP::Z.tdiv Bignum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.tdiv(@c).class,    "GMP::Z.tdiv GMP::Z should be GMP::Z.")
+    assert_equal(0, @a.tdiv(@b), "GMP::Z.tdiv should work.")
+    assert_equal(1, @b.tdiv(@a), "GMP::Z.tdiv should work.")
+    assert_equal(1, @a.tdiv( 3), "GMP::Z.tdiv should work.")
+    assert_equal(0, @a.tdiv(@c), "GMP::Z.tdiv should work.")
+    assert_equal(5, @c.tdiv(@a), "GMP::Z.tdiv should work.")
+  end
+  
+  def test_z_fdiv
+    assert_equal(GMP::Z, @a.fdiv(@b).class,    "GMP::Z.fdiv GMP::Z should be GMP::Z.")
+    assert_equal(GMP::Z, @a.fdiv(3).class,     "GMP::Z.fdiv Fixnum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.fdiv(2**32).class, "GMP::Z.fdiv Bignum should be GMP::Z.")
+    assert_equal(0, @a.fdiv(@b), "GMP::Z.fdiv should work.")
+    assert_equal(1, @b.fdiv(@a), "GMP::Z.fdiv should work.")
+    assert_equal(1, @a.fdiv( 3), "GMP::Z.fdiv should work.")
+    assert_equal(0, @a.fdiv(@c), "GMP::Z.fdiv should work.")
+    assert_equal(5, @c.fdiv(@a), "GMP::Z.fdiv should work.")
+  end
+  
+  def test_z_cdiv
+    assert_equal(GMP::Z, @a.cdiv(@b).class,    "GMP::Z.cdiv GMP::Z should be GMP::Z.")
+    assert_equal(GMP::Z, @a.cdiv(3).class,     "GMP::Z.cdiv Fixnum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.cdiv(2**32).class, "GMP::Z.cdiv Bignum should be GMP::Z.")
+    assert_equal(1, @a.cdiv(@b), "GMP::Z.cdiv should work.")
+    assert_equal(2, @b.cdiv(@a), "GMP::Z.cdiv should work.")
+    assert_equal(2, @a.cdiv( 3), "GMP::Z.cdiv should work.")
+    assert_equal(1, @a.cdiv(@c), "GMP::Z.cdiv should work.")
+    assert_equal(5, @c.cdiv(@a), "GMP::Z.cdiv should work.")
+  end
+  
+  def test_z_tmod
+    assert_equal(GMP::Z, @a.tmod(@b).class,    "GMP::Z.tmod GMP::Z should be GMP::Z.")
+    assert_equal(GMP::Z, @a.tmod(3).class,     "GMP::Z.tmod Fixnum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.tmod(2**32).class, "GMP::Z.tmod Bignum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.tmod(@c).class,    "GMP::Z.tmod GMP::Z should be GMP::Z.")
+    assert_equal(5, @a.tmod(@b), "GMP::Z.tmod should work.")
+    assert_equal(2, @b.tmod(@a), "GMP::Z.tmod should work.")
+    assert_equal(2, @a.tmod( 3), "GMP::Z.tmod should work.")
+    assert_equal(5, @a.tmod(@c), "GMP::Z.tmod should work.")
+    assert_equal(0, @c.tmod(@a), "GMP::Z.tmod should work.")
+  end
+  
+  def test_z_fmod
+    assert_equal(GMP::Z, @a.fmod(@b).class,    "GMP::Z.fmod GMP::Z should be GMP::Z.")
+    assert_equal(GMP::Z, @a.fmod(3).class,     "GMP::Z.fmod Fixnum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.fmod(2**32).class, "GMP::Z.fmod Bignum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.fmod(@c).class,    "GMP::Z.fmod GMP::Z should be GMP::Z.")
+    assert_equal(5, @a.fmod(@b), "GMP::Z.fmod should work.")
+    assert_equal(2, @b.fmod(@a), "GMP::Z.fmod should work.")
+    assert_equal(2, @a.fmod( 3), "GMP::Z.fmod should work.")
+    assert_equal(5, @a.fmod(@c), "GMP::Z.fmod should work.")
+    assert_equal(0, @c.fmod(@a), "GMP::Z.fmod should work.")
+  end
+  
+  def test_z_cmod
+    assert_equal(GMP::Z, @a.cmod(@b).class,    "GMP::Z.cmod GMP::Z should be GMP::Z.")
+    assert_equal(GMP::Z, @a.cmod(3).class,     "GMP::Z.cmod Fixnum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.cmod(2**32).class, "GMP::Z.cmod Bignum should be GMP::Z.")
+    assert_equal(GMP::Z, @a.cmod(@c).class,    "GMP::Z.cmod GMP::Z should be GMP::Z.")
+    assert_equal( -2, @a.cmod(@b), "GMP::Z.cmod should work.")
+    assert_equal( -3, @b.cmod(@a), "GMP::Z.cmod should work.")
+    assert_equal( -1, @a.cmod( 3), "GMP::Z.cmod should work.")
+    assert_equal(-20, @a.cmod(@c), "GMP::Z.cmod should work.")
+    assert_equal(  0, @c.cmod(@a), "GMP::Z.cmod should work.")
+  end
+  
+  def test_z_mod
+    assert_equal(5,       @a % @b, "GMP::Z should % GMP::Z correctly.")
+    assert_equal(2,       @b % @a, "GMP::Z should % GMP::Z correctly.")
+    assert_equal(2,       @b %  5, "GMP::Z should % Fixnum correctly.")
+    assert_equal(0,       @b % @b, "GMP::Z should % to 0 correctly.")
+    assert_equal(0,       @c % @a, "GMP::Z should % to 0 correctly.")
+    assert_equal(0,       @f % @f, "GMP::Z should % Bignum correctly.")
+    assert_equal(0,     2*@f % @f, "GMP::Z should % Bignum correctly.")
+    assert_equal(5, (5*@f+5) % @f, "GMP::Z should % Bignum correctly.")
+    assert_raise(TypeError) { @a % 3.14 }
+    assert_raise(TypeError) { @a % GMP::Q(22,3) }
+    assert_raise(TypeError) { @a % GMP::F(3.14) }
+  end
+end