gmp 0.1.8 → 0.1.9

data/CHANGELOG

@@ -1,4 +1,7 @@
-0.18:
+0.1.9:
+  * Cleaning up more documentation in PDF format.
+
+0.1.8:
   * Added test: tc_division, in progress.
   * Unit test results: 56 tests, 361 assertions, 0 failures, 0 errors
   * Added to_f ==> to_d aliases for GMP::Q and GMP::F.

data/manual.tex

@@ -1,23 +1,33 @@
 \documentclass[pdftex,10pt]{article}
 \usepackage{amsmath,amsfonts,url}
 \usepackage[pdftex]{graphicx}
+\usepackage{booktabs}
+\usepackage{url}
 \setlength{\parindent}{0pt}
-\newcommand{\HRule}{\rule{\linewidth}{0.8mm}}
-\newcommand{\sectionline}{\rule{1.0\linewidth}{2.0pt}}
 \def\cour{\fontfamily{pcr}\selectfont}
-\usepackage[top=1.2in, bottom=0.8in, left=0.8in, right=0.8in]{geometry}
+\usepackage[top=1in, bottom=0.8in, left=0.8in, right=0.8in]{geometry}
 \setcounter{tocdepth}{3}
-\title{gmp - Ruby bindings to the GMP library}
-\date{September 27, 2009}
-\author{Sam Rawlins}
+\newlength{\titrwidth}
+\setlength{\titrwidth}{\textwidth}
+\addtolength{\titrwidth}{-1.2in}
+\newlength{\methwidth}
+\setlength{\methwidth}{0.8in}
+\newlength{\defnwidth}
+\setlength{\defnwidth}{\textwidth}
+\addtolength{\defnwidth}{-1.2in}
+\addtolength{\heavyrulewidth}{\heavyrulewidth}
+\def\qquad{\quad\quad}
+\def\qqqquad{\quad\quad\quad\quad}
 \begin{document}
-\huge{gmp}\\
-\HRule
-\begin{flushright}
-\large{Ruby bindings to the GMP library}\\
-\large{Edition 0.1.5}\\
-\large{27 September 2009}\\
-\end{flushright}
+
+\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.1.9}}\\
+\multicolumn{2}{r}{\large{23 November 2009}}
+\end{tabular}
+
 \vfill
 \large{written by Sam Rawlins}\\
 \large{with extensive quoting from the GMP Manual}
@@ -63,13 +73,17 @@ 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}
 \\
-\indent \texttt{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}
 \\
+
 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.\\
 \\
@@ -119,8 +133,8 @@ That's all. I don't intend to test any older versions, maybe 4.3.0 for completen
 
 Here is a table of the exact environments I have tested the gmp gem on:\\\\
 
-\begin{tabular}{|l|r|r|} \hline
-             Platform             &       Ruby       &    GMP    \\ \hline \hline
+\begin{tabular}{lrr} \hline
+             Platform             &       Ruby       &    GMP    \\ \midrule[1pt]
   Cygwin on x86                   & (MRI) Ruby 1.8.7 & GMP 4.3.1 \\ \hline
   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
@@ -130,18 +144,18 @@ Here is a table of the exact environments I have tested the gmp gem on:\\\\
 \subsection{Installing}
 You may clone the gmp gem's git repository with:\\
 \\
-\hangindent=0.5cm \texttt{git clone git://github.com/srawlins/gmp.git}\\
+\texttt{git clone git://github.com/srawlins/gmp.git}\\
 
 Or you may install the gem from github:\\
 \\
-\hangindent=0.5cm \texttt{gem install srawlins-gmp}\\
+\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:\\
 \\
-\hangindent=0.5cm \texttt{cd <srawlins-gmp gem directory>/ext}\\
-\hangindent=0.5cm \texttt{ruby extconf.rb}\\
-\hangindent=0.5cm \texttt{make}\\
+\texttt{cd <srawlins-gmp gem directory>/ext}\\
+\texttt{ruby extconf.rb}\\
+\texttt{make}\\
 
 There shouldn't be any errors, or warnings.
 
@@ -163,74 +177,274 @@ In addition to the above three classes, there is also one constant within \textt
   \item \texttt{GMP::GMP\_VERSION} - The version of GMP compiled into the gmp gem.
 \end{itemize}
 
+\newpage
 \section{Integer Functions}
 
 \subsection{Initializing, Assigning Integers}
 
-\large{\textbf{GMP::Z.new(a = 0)}}\\
-\large{\textbf{GMP::Z(a = 0)}}\\
-This method creates a new \texttt{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
-examples:
-\begin{verbatim}
-GMP::Z.new                  #=> 0           (default)
-GMP::Z.new(1)               #=> 1           (Ruby Fixnum)
-GMP::Z.new("127")           #=> 127         (Ruby String)
-GMP::Z.new(4294967296)      #=> 4294967296  (Ruby Bignum)
-GMP::Z.new(GMP::Z.new(31))  #=> 31          (GMP Integer)
-\end{verbatim}
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{new} & & GMP::Z.new $\rightarrow$ \textit{integer} \\
+& & GMP::Z.new(\textit{numeric = 0}) $\rightarrow$ \textit{integer} \\
+& & 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
+  examples:\newline
+  
+  \texttt{GMP::Z.new \qqqquad\qqqquad \#=> 0 (default) \newline
+          GMP::Z.new(1) \qqqquad\qquad\  \#=> 1 (Ruby Fixnum) \newline
+          GMP::Z.new("127") \qqqquad\  \#=> 127 (Ruby String)\newline
+          GMP::Z.new(4294967296) \qquad \#=> 4294967296 (Ruby Bignum)\newline
+          GMP::Z.new(GMP::Z.new(31))  \#=> 31 (GMP Integer)}
+}
+\end{tabular}
+\newline\newline
 
 There is also a convenience method available, \texttt{GMP::Z()}.\\
 
 \subsection{Converting Integers}
 
-\large{\textbf{integer.to\_d -> Float}}\\
-Returns \texttt{integer} as an Float if \texttt{integer} fits in a Float.\\
-\\
-Otherwise returns the least significant part of \texttt{integer}, with the same sign as
-\texttt{integer}.\\
-\\
-If \texttt{integer} is too big to fit in a Float, the returned result is probably not
-very useful. To find out if the value will fit, use the function
-\texttt{mpz\_fits\_slong\_p} (\textbf{Unimplemented}).\\
-\\
-\large{\textbf{integer.to\_i -> Fixnum}}\\
-Returns \texttt{integer} as a Fixnum if \texttt{integer} fits in a Fixnum.\\
-\\
-Otherwise returns the least significant part of \texttt{integer}, with the same sign as
-\texttt{integer}.\\
-\\
-If \texttt{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
-\texttt{mpz\_fits\_slong\_p} (\textbf{Unimplemented}).\\
-\\
-\large{\textbf{integer.to\_s(base = 10) -> String}}\\
-Returns \texttt{integer}, as a Ruby string. If \texttt{base} is not provided, then the
-string will be the decimal representation.\\
-\\
-From the GMP Manual:\\
-\\
-Convert \texttt{integer} to a string of digits in base \texttt{base}. The \texttt{base}
-argument may vary from 2 to 62 or from -2 to -36.\\
-\\
-For \texttt{base} in the range 2..36, digits and lower-case letters are used; for
--2..-36, digits and upper-case letters are used; for 37..62, digits, upper-case letters,
-and lower-case letters (in that significance order) are used.\\
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{to\_d} & & \textit{integer}.to\_d $\rightarrow$ \textit{float} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns \textit{integer} as an Float if \textit{integer} fits in a Float.
+
+  Otherwise returns the least significant part of \texttt{integer}, with the same sign as
+  \textit{integer}.
+  
+  If \textit{integer} is too big to fit in a Float, 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}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{to\_i} & & \textit{integer}.to\_i $\rightarrow$ \textit{fixnum} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns \textit{integer} as a Fixnum if \textit{integer} fits in a Fixnum.
+  \newline
+  
+  Otherwise returns the least significant part of \textit{integer}, with the same sign as
+  \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
+  \textit{mpz\_fits\_slong\_p} (\textbf{Unimplemented}).
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{to\_s} & & \textit{integer}.to\_s(\textit{base = 10}) $\rightarrow$ \textit{str} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Converts \textit{integer} to a string of digits in base \textit{base}. The
+  \textit{base} argument may vary from 2 to 62 or from -2 to -36, or be a symbol, one of
+  \textit{:bin}, \textit{:oct}, \textit{:dec}, or \textit{:hex}.
+  \newline
+  
+  For \textit{base} in the range 2..36, digits and lower-case letters are used; for
+  -2..-36 (and \textit{:bin}, \textit{:oct}, \textit{:dec}, and \textit{:hex}), digits
+  and upper-case letters are used; for 37..62, digits, upper-case letters, and lower-case
+  letters (in that significance order) are used. Here are some
+  examples:\newline
+  
+  \texttt{GMP::Z(1).to\_s \qqqquad \#=> "1" \newline
+          GMP::Z(32).to\_s(2) \qquad \#=> "100000" \newline
+          GMP::Z(32).to\_s(4) \qquad \#=> "200" \newline
+          GMP::Z(10).to\_s(16) \quad\  \#=> "a" \newline
+          GMP::Z(10).to\_s(-16) \quad \#=> "A" \newline
+          GMP::Z(255).to\_s(:bin) \#=> "11111111" \newline
+          GMP::Z(255).to\_s(:oct) \#=> "377" \newline
+          GMP::Z(255).to\_s(:dec) \#=> "255" \newline
+          GMP::Z(255).to\_s(:hex) \#=> "ff"}
+}
+\end{tabular}
 
 \subsection{Integer Arithmetic}
 
-\large{\textbf{integer.add(b)}}\\
-\large{\textbf{integer + b}}\\
-\large{\textbf{integer.add!(b)}}\\
-Adds \texttt{integer} to \texttt{b}. \texttt{add} and \texttt{+} return the result.
-\texttt{add!} sets \texttt{integer} to the result. \texttt{b} can be a member of one of
-the following classes:
-\begin{verbatim}
-  GMP::Z
-  Fixnum
-  GMP::Q
-  GMP::F
-  Bignum
-\end{verbatim}
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\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
+  \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}}{
+  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
+  \textit{Bignum}.
+}
+\end{tabular}
+\newline\newline
+
+\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
+  \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{*} & & \textit{integer} * \textit{numeric} $\rightarrow$ \textit{numeric} \\
+& & \textit{integer}.mul(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
+& & \textit{integer}.mul!(\textit{numeric}) $\rightarrow$ \textit{numeric} \\
+\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}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{-@} & & -\textit{integer}\\
+& & \textit{integer}.neg\\
+& & \textit{integer}.neg!\\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the negation, the additive inverse, of \textit{integer}. The destructive method
+  negates in place.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{abs} & & \textit{integer}.abs\\
+& & \textit{integer}.abs!\\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns the absolute value of \textit{integer}. The destructive method calculates the
+  absolute value in place.
+}
+\end{tabular}
+
+\subsection{Integer Division}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{tdiv} & & \textit{integer}.tdiv(\textit{numeric}) $\rightarrow$ \textit{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}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{fdiv} & & \textit{integer}.fdiv(\textit{numeric}) $\rightarrow$ \textit{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}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{cdiv} & & \textit{integer}.cdiv(\textit{numeric}) $\rightarrow$ \textit{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}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{tmod} & & \textit{integer}.tmod(\textit{numeric}) $\rightarrow$ \textit{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}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{fmod} & & \textit{integer}.fmod(\textit{numeric}) $\rightarrow$ \textit{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}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\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}.
+}
+\end{tabular}
+
+\subsection{Integer Exponentiation}
+
+\subsection{Integer Roots}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\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}.
+}
+\end{tabular}
 
 \end{document}

data/test/unit_tests.rb

@@ -96,4 +96,28 @@ class TC_division < Test::Unit::TestCase
     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
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gmp
 version: !ruby/object:Gem::Version 
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors: 
 - Tomasz Wegrzanowski
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-20 00:00:00 -07:00
+date: 2009-11-23 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -58,6 +58,7 @@ files:
 - CHANGELOG
 - INSTALL
 - README.rdoc
+- manual.pdf
 - manual.tex
 has_rdoc: false
 homepage: http://github.com/srawlins/gmp