gmp 0.2.1 → 0.2.2

data/ext/ruby_gmp.h

@@ -62,11 +62,12 @@ typedef __mpf_struct MP_FLOAT;
 #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 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_ZXB "Expected GMP::Z, FixNum or BigNum"
-#define EXPECTED_ZX "Expected GMP::Z or FixNum"
-#define EXPECTED_X "Expected FixNum"
+#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_ZXB "Expected GMP::Z, Fixnum or Bignum"
+#define EXPECTED_ZX "Expected GMP::Z or Fixnum"
+#define EXPECTED_X "Expected Fixnum"
+#define EXPECTED_Z "Expected GMP::Z"
 #define typeerror(expected) rb_raise(rb_eTypeError, EXPECTED_##expected)
 #define typeerror_as(expected, argname) rb_raise(rb_eTypeError, EXPECTED_##expected " as " argname)
 
@@ -105,6 +106,10 @@ extern VALUE r_gmpz_mul(VALUE self, VALUE arg);
 extern VALUE r_gmpzsg_pow(VALUE klass, VALUE base, VALUE exp);
 
 // Number Theoretic Functions
+extern VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self);
+extern VALUE r_gmpz_jacobi(VALUE self, VALUE b);
+extern VALUE r_gmpzsg_jacobi(VALUE klass, VALUE a, VALUE b);
+extern VALUE r_gmpz_legendre(VALUE self, VALUE p);
 extern VALUE r_gmpz_remove(VALUE self, VALUE arg);
 
 // Integer Comparisons
@@ -114,10 +119,7 @@ extern VALUE r_gmpz_cmpabs(VALUE self, VALUE arg);
 
 // _unsorted_
 extern VALUE r_gmpz_div(VALUE self, VALUE arg);
-extern VALUE r_gmpz_is_probab_prime(int argc, VALUE* argv, VALUE self);
 extern VALUE r_gmpz_popcount(VALUE self);
-extern VALUE r_gmpz_jacobi(VALUE self);
-extern VALUE r_gmpz_legendre(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);

data/manual.tex

@@ -18,13 +18,15 @@
 \addtolength{\heavyrulewidth}{\heavyrulewidth}
 \def\qquad{\quad\quad}
 \def\qqqquad{\quad\quad\quad\quad}
+\def\cc{\colon\colon}
+\frenchspacing
 \begin{document}
 
 \begin{tabular}{p{1.0in} p{\titrwidth}}
 \huge{gmp} &\\
 \midrule[3pt]
 \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
-\multicolumn{2}{r}{\large{Edition 0.2.1}}\\
+\multicolumn{2}{r}{\large{Edition 0.2.2}}\\
 \multicolumn{2}{r}{\large{21 December 2009}}
 \end{tabular}
 
@@ -164,11 +166,11 @@ There shouldn't be any errors, or warnings.
 \subsection{Classes}
 The gmp gem includes the namespace \texttt{GMP} and three classes within \texttt{GMP}:
 \begin{itemize}
-  \item \texttt{GMP::Z} - Methods for signed integer arithmetic. There are at least 35
+  \item \texttt{GMP::Z} - Methods for signed integer arithmetic. There are at least 45
     methods here (still accounting).
-  \item \texttt{GMP::Q} - Methods for rational number arithmetic. There are at least 6
+  \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 0
+  \item \texttt{GMP::F} - Methods for floating-point arithmetic. There are at least 6
     methods here (still accounting).
 \end{itemize}
 
@@ -277,20 +279,8 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \textbf{+} & & \textit{integer} + \textit{numeric} $\rightarrow$ \textit{numeric} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the sum of \textit{integer} and \textit{numeric}. \textit{numeric} can be a
-  member of \textit{GMP::Z}, \textit{Fixnum}, \textit{GMP::Q}, \textit{GMP::F}, or
-  \textit{Bignum}.
-}
-\end{tabular}
-\newline\newline
-
-\begin{tabular}{p{\methwidth} l r}
-\toprule
-\textbf{add} & & \textit{integer}.add(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
-\cmidrule(r){2-3}
-& \multicolumn{2}{p{\defnwidth}}{
-  Returns the sum of \textit{integer} and \textit{numeric}. \textit{numeric} can be a
-  member of \textit{GMP::Z}, \textit{Fixnum}, \textit{GMP::Q}, \textit{GMP::F}, or
+  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}.
 }
 \end{tabular}
@@ -302,8 +292,8 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \textit{numeric} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Sums \textit{integer} and \textit{numeric}, in place. \textit{numeric} can be a
-  member of \textit{GMP::Z}, \textit{Fixnum}, \textit{GMP::Q}, \textit{GMP::F}, or
+  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}.
 }
 \end{tabular}
@@ -312,12 +302,11 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \begin{tabular}{p{\methwidth} l r}
 \toprule
 \textbf{-} & & \textit{integer} - \textit{numeric} $\rightarrow$ \textit{numeric} \\
-& & \textit{integer}.sub(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
 & & \textit{integer}.sub!(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
 \cmidrule(r){2-3}
 & \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 a member of
+  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
   
@@ -344,8 +333,19 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \cmidrule(r){2-3}
 & \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 a member of \textit{GMP::Z},
-  \textit{Fixnum}, \textit{GMP::Q}, \textit{GMP::F}, or \textit{Bignum}.
+  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}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{\textless\textless} & & \textit{integer} \textless\textless \textit{numeric} $\rightarrow$ \textit{integer} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns \textit{integer} times 2 to the \textit{numeric} power. This can also be
+  defined as a left shift by \textit{numeric} bits.
 }
 \end{tabular}
 \newline\newline
@@ -378,60 +378,57 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
-\textbf{tdiv} & & \textit{integer}.tdiv(\textit{numeric}) $\rightarrow$ \textit{integer}\\
+\textbf{tdiv} & & $integer$.tdiv($numeric$) $\rightarrow$ $integer$\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the division of \textit{integer} by \textit{numeric}, truncated.
-  \textit{numeric} can be a member of \textit{GMP::Z}, \textit{Fixnum}, \textit{Bignum}.
-  The return object's class is always \textit{GMP::Z}.
+  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$.
 }
 \end{tabular}
 \newline\newline
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
-\textbf{fdiv} & & \textit{integer}.fdiv(\textit{numeric}) $\rightarrow$ \textit{integer}\\
+\textbf{fdiv} & & $integer$.fdiv($numeric$) $\rightarrow$ $integer$\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the division of \textit{integer} by \textit{numeric}, floored.
-  \textit{numeric} can be a member of \textit{GMP::Z}, \textit{Fixnum}, \textit{Bignum}.
-  The return object's class is always \textit{GMP::Z}.
+  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$.
 }
 \end{tabular}
 \newline\newline
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
-\textbf{cdiv} & & \textit{integer}.cdiv(\textit{numeric}) $\rightarrow$ \textit{integer}\\
+\textbf{cdiv} & & $integer$.cdiv($numeric$) $\rightarrow$ $integer$\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the ceiling division of \textit{integer} by \textit{numeric}.
-  \textit{numeric} can be a member of \textit{GMP::Z}, \textit{Fixnum}, \textit{Bignum}.
-  The return object's class is always \textit{GMP::Z}.
+  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$.
 }
 \end{tabular}
 \newline\newline
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
-\textbf{tmod} & & \textit{integer}.tmod(\textit{numeric}) $\rightarrow$ \textit{integer}\\
+\textbf{tmod} & & $integer$.tmod($numeric$) $\rightarrow$ $integer$\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the remainder after truncated division of \textit{integer} by \textit{numeric}.
-  \textit{numeric} can be a member of \textit{GMP::Z}, \textit{Fixnum}, \textit{Bignum}.
-  The return object's class is always \textit{GMP::Z}.
+  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
+  $GMP::Z$.
 }
 \end{tabular}
 \newline\newline
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
-\textbf{fmod} & & \textit{integer}.fmod(\textit{numeric}) $\rightarrow$ \textit{integer}\\
+\textbf{fmod} & & $integer$.fmod($numeric$) $\rightarrow$ $integer$\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the remainder after floored division of \textit{integer} by \textit{numeric}.
-  \textit{numeric} can be a member of \textit{GMP::Z}, \textit{Fixnum}, \textit{Bignum}.
-  The return object's class is always \textit{GMP::Z}.
+  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
+  $GMP::Z$.
 }
 \end{tabular}
 \newline\newline
@@ -441,9 +438,9 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \textbf{cmod} & & \textit{integer}.cmod(\textit{numeric}) $\rightarrow$ \textit{integer}\\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the remainder after ceilinged division of \textit{integer} by \textit{numeric}.
-  \textit{numeric} can be a member of \textit{GMP::Z}, \textit{Fixnum}, \textit{Bignum}.
-  The return object's class is always \textit{GMP::Z}.
+  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
+  $GMP::Z$.
 }
 \end{tabular}
 
@@ -454,7 +451,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \textbf{root} & & \textit{integer}.root(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the integer part of the \textit{numeric}'th root of \textit{integer}.
+  Returns the integer part of the $numeric$'th root of $integer$.
 }
 \end{tabular}
 \newline\newline
@@ -465,7 +462,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 & & \textit{integer}.sqrt!(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the truncated integer part of the square root of \textit{integer}.
+  Returns the truncated integer part of the square root of $integer$.
 }
 \end{tabular}
 \newline\newline
@@ -475,9 +472,35 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \textbf{sqrtrem} & & \textit{integer}.sqrtrem $\rightarrow$ \textit{sqrt}, \textit{rem} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns the truncated integer part of the square root of \textit{integer} as
-  \textit{sqrt} and the remainder, \textit{integer - sqrt * sqrt}, as \textit{rem}, which
-  will be zero if \textit{integer} is a perfect square.
+  Returns the truncated integer part of the square root of $integer$ as $sqrt$ and the
+  remainder, $integer - sqrt * sqrt$, as $rem$, which will be zero if $integer$ is a
+  perfect square.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{power?} & & \textit{integer}.power? $\rightarrow$ \textit{true} \textbar\  \textit{false} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns true if $integer$ is a perfect power, i.e., if there exist integers $a$ and
+  $b$, with $b > 1$, such that $integer$ equals $a$ raised to the power $b$.
+  \newline\newline
+  Under this definition both 0 and 1 are considered to be perfect powers. Negative values
+  of integers are accepted, but of course can only be odd perfect powers.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{square?} & & \textit{integer}.square? $\rightarrow$ \textit{true} \textbar\  \textit{false} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns true if $integer$ is a perfect square, i.e., if the square root of
+  $integer$ is an integer. Under this definition both 0 and 1 are considered to be
+  perfect squares.
 }
 \end{tabular}
 
@@ -489,7 +512,98 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 & & \textit{integer}.pow(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Returns \textit{integer} raised to the \textit{numeric} power.
+  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}
+\toprule
+\textbf{is\_probab\_prime?} & & $integer$.is\_probab\_prime?($reps = 5$) $\rightarrow$ 0, 1, or 2 \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Determine whether $integer$ is prime. Returns 2 if $integer$ is definitely prime,
+  returns 1 if $integer$ is probably prime (without being certain), or returns 0 if
+  $integer$ is definitely composite. 
+  \newline\newline
+  This function does some trial divisions, then some Miller-Rabin probabilistic primality
+  tests. $reps$ controls how many such tests are done, 5 to 10 is a reasonable number,
+  more will reduce the chances of a composite being returned as �probably prime�.
+  \newline\newline
+  Miller-Rabin and similar tests can be more properly called compositeness tests. Numbers
+  which fail are known to be composite but those which pass might be prime or might be
+  composite. Only a few composites pass, hence those which pass are considered probably
+  prime.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{next\_prime} & & $integer$.next\_prime $\rightarrow$ $prime$ \\
+& & $integer$.nextprime $\rightarrow$ $prime$ \\
+& & $integer$.next\_prime! $\rightarrow$ $prime$ \\
+& & $integer$.nextprime! $\rightarrow$ $prime$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the next prime greater than $integer$. The destructive method sets $integer$ to
+  the next prime greater than $integer$.
+  \newline\newline
+  This function uses a probabilistic algorithm to identify primes. For practical purposes
+  it's adequate, the chance of a composite passing will be extremely small.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{jacobi} & & $a$.jacobi($b$) $\rightarrow$ $integer$ \\
+& & GMP::Z.jacobi($a$, $b$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  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$.
+  \newline
+  $GMP::Z\#jacobi$ (the class method) requires $a$ and $b$ each to be an instance of
+  $GMP::Z$, $Fixnum$, or $Bignum$.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{legendre} & & $a$.legendre($b$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the Legendre symbol $(a/b)$. This is defined only for $p$ an odd positive
+  prime. If $p$ is even, negative, or composite, a range exception will be raised.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{remove} & & $n$.remove($factor$) $\rightarrow$ ($integer$, $times$) \\
+\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$.
 }
 \end{tabular}
 

data/test/README

@@ -29,8 +29,8 @@ Tests:
   21    mpfr - trigonometry
   22    mpfr - type tests
   23    mpfr - sqrt and power
+  24    jacobi, legendre, remove
 TODO:
-  jacobi, legendre, remove
   gcd, lcm
   cmpabs
   integer and integer->rational division, modulo

data/test/tc_fib_fac_nextprime.rb

@@ -41,11 +41,11 @@ class TC_fib_fac_nextprime < Test::Unit::TestCase
   end
 
   def test_nextprime
-    assert_equal(@z11,  @z7.nextprime, "GMP::Z.nextprime should work.")
-    assert_equal(@z11,  @z8.nextprime, "GMP::Z.nextprime should work.")
-    assert_equal(@z11,  @z8.nextprime, "GMP::Z.nextprime should work.")
-    assert_equal(@z13, @z11.nextprime, "GMP::Z.nextprime should work.")
-    assert_equal(@z17, @z13.nextprime, "GMP::Z.nextprime should work.")
-    assert_equal(@z19, @z17.nextprime, "GMP::Z.nextprime should work.")
+    assert_equal(@z11,  @z7.next_prime, "GMP::Z.nextprime should work.")
+    assert_equal(@z11,  @z8.nextprime,  "GMP::Z.nextprime should work.")
+    assert_equal(@z11,  @z8.next_prime, "GMP::Z.nextprime should work.")
+    assert_equal(@z13, @z11.nextprime,  "GMP::Z.nextprime should work.")
+    assert_equal(@z17, @z13.next_prime, "GMP::Z.nextprime should work.")
+    assert_equal(@z19, @z17.nextprime,  "GMP::Z.nextprime should work.")
   end
 end

data/test/tc_z_jac_leg_rem.rb

@@ -0,0 +1,73 @@
+require 'test_helper'
+
+class TC_Z_Jacobi_Legendre_Remove < Test::Unit::TestCase
+  def setup
+    @one         = GMP::Z(1)
+    @two         = GMP::Z(2)
+    @three       = GMP::Z(3)
+    @four        = GMP::Z(4)
+    @five        = GMP::Z(5)
+    @nine        = GMP::Z(9)
+    @forty_five  = GMP::Z(45)
+    @neg_one     = GMP::Z(-1)
+  end
+  
+  # I don't actually know the Jacobi symbol, so these are just from Wolfram Alpha.
+  def test_jacobi
+    assert_equal(@one.jacobi(@one),          1, "GMP::Z should jacobi(GMP::Z) correctly")
+    assert_equal(@two.jacobi(@one),          1, "GMP::Z should jacobi(GMP::Z) correctly")
+    assert_equal(@forty_five.jacobi(@one),   1, "GMP::Z should jacobi(GMP::Z) correctly")
+    assert_equal(@one.jacobi(@three),        1, "GMP::Z should jacobi(GMP::Z) correctly")
+    assert_equal(@two.jacobi(@three),       -1, "GMP::Z should jacobi(GMP::Z) correctly")
+    assert_equal(@three.jacobi(@three),      0, "GMP::Z should jacobi(GMP::Z) correctly")
+    assert_equal(@forty_five.jacobi(@three), 0, "GMP::Z should jacobi(GMP::Z) correctly")
+    
+    assert_equal(GMP::Z.jacobi(@one, @one),     1, "GMP::Z should jacobi(GMP::Z, GMP::Z) correctly")
+    assert_equal(GMP::Z.jacobi(@four, @one),    1, "GMP::Z should jacobi(GMP::Z, GMP::Z) correctly")
+    assert_equal(GMP::Z.jacobi(@two, @three),  -1, "GMP::Z should jacobi(GMP::Z, GMP::Z) correctly")
+    assert_equal(GMP::Z.jacobi(@three, @three), 0, "GMP::Z should jacobi(GMP::Z, GMP::Z) correctly")
+    
+    assert_equal(GMP::Z.jacobi(1, @one),    1, "GMP::Z should jacobi(Fixnum, GMP::Z) correctly")
+    assert_equal(GMP::Z.jacobi(4, @one),    1, "GMP::Z should jacobi(Fixnum, GMP::Z) correctly")
+    assert_equal(GMP::Z.jacobi(2, @three), -1, "GMP::Z should jacobi(Fixnum, GMP::Z) correctly")
+    assert_equal(GMP::Z.jacobi(3, @three),  0, "GMP::Z should jacobi(Fixnum, GMP::Z) correctly")
+    
+    assert_equal(GMP::Z.jacobi(@one, 1),   1, "GMP::Z should jacobi(GMP::Z, Fixnum) correctly")
+    assert_equal(GMP::Z.jacobi(@four, 1),  1, "GMP::Z should jacobi(GMP::Z, Fixnum) correctly")
+    assert_equal(GMP::Z.jacobi(@two, 3),  -1, "GMP::Z should jacobi(GMP::Z, Fixnum) correctly")
+    assert_equal(GMP::Z.jacobi(@three, 3), 0, "GMP::Z should jacobi(GMP::Z, Fixnum) correctly")
+    
+    assert_equal(GMP::Z.jacobi(1, 1),  1, "GMP::Z should jacobi(Fixnum, Fixnum) correctly")
+    assert_equal(GMP::Z.jacobi(4, 1),  1, "GMP::Z should jacobi(Fixnum, Fixnum) correctly")
+    assert_equal(GMP::Z.jacobi(2, 3), -1, "GMP::Z should jacobi(Fixnum, Fixnum) correctly")
+    assert_equal(GMP::Z.jacobi(3, 3),  0, "GMP::Z should jacobi(Fixnum, Fixnum) correctly")
+    
+    assert_raise(RangeError) {   @two.jacobi(@two) }
+    assert_raise(RangeError) { @three.jacobi(@neg_one) }
+    assert_raise(RangeError) { GMP::Z.jacobi(@two, @two) }
+    assert_raise(RangeError) { GMP::Z.jacobi(@three, @neg_one) }
+    assert_raise(RangeError) { GMP::Z.jacobi(@two, 2) }
+    assert_raise(RangeError) { GMP::Z.jacobi(3, @neg_one) }
+    assert_raise(RangeError) { GMP::Z.jacobi(3, -1) }
+  end
+  
+  def test_legendre
+    assert_equal(@one.legendre(@three),  1, "GMP::Z should legendre(GMP::Z) correctly")
+    assert_equal(@two.legendre(@three), -1, "GMP::Z should legendre(GMP::Z) correctly")
+    
+    assert_raise(RangeError) { @one.legendre(@one) }
+    assert_raise(RangeError) { @one.legendre(@two) }
+    assert_raise(RangeError) { @one.legendre(@neg_one) }
+    assert_raise(RangeError) { @one.legendre(@four) }
+    assert_raise(RangeError) { @one.legendre(@nine) }
+  end
+  
+  def test_remove
+    assert_equal(@nine, @forty_five.remove(5)[0],      "GMP::Z should remove(GMP::Z) correctly.")
+    assert_equal(@nine, @forty_five.remove(@five)[0],  "GMP::Z should remove(GMP::Z) correctly.")
+    assert_equal(@five, @forty_five.remove(@three)[0], "GMP::Z should remove(GMP::Z) correctly.")
+    assert_equal(1, @forty_five.remove(5)[1],      "GMP::Z should remove(GMP::Z) correctly.")
+    assert_equal(1, @forty_five.remove(@five)[1],  "GMP::Z should remove(GMP::Z) correctly.")
+    assert_equal(2, @forty_five.remove(@three)[1], "GMP::Z should remove(GMP::Z) correctly.")
+  end
+end