gmp 0.1.7 → 0.1.8

data/CHANGELOG

@@ -1,3 +1,17 @@
+0.18:
+  * 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.
+
+0.1.7:
+  * Added tests: tc_shifts_last_bits, tc_logical_roots, tc_f_precision,
+    tc_f_arithmetics_coersion, tc_default_prec
+  * Unit test results: 54 tests, 326 assertions, 0 failures, 0 errors
+  * Fixed defect in GMP::F.sub when argument is Bignum
+  * Fixed defect in GMP::F.div when argument is Bignum
+  * Added documentation "manual" in form of a LaTeX-based PDF. Very incomplete
+  * as of yet.
+
 0.1.6.2:
   * Added optional argument to GMP::Z.to_s. Supply base as either a Fixnum or
     a Symbol like :hex to get the string in a different base.

data/README.rdoc

@@ -241,11 +241,11 @@ still relevant.
 * better bignum parser
 * zero-copy method for strings generation
 * put rb_raise into nice macros
-* benchmarks against Python GMP and Perl GMP
+* benchmarks against Python GMP (gmpy? Is this still active?) and Perl GMP (I can't
+  find this either!)
 * dup methods
 * integrate F into system
 * should Z.[] bits be 0/1 or true/false, 0 is true, what might badly surprise users
-* seriously investigate Ruby Makefile-making system
 * any2small_integer()
 * check asm output, especially local memory efficiency
 * it might be better to use `register' for some local variables

data/ext/gmpq.c

@@ -743,6 +743,7 @@ void init_gmpq()
   
   // Rational Conversions
   rb_define_method(cGMP_Q, "to_d", r_gmpq_to_d, 0);
+  rb_define_alias(cGMP_Q, "to_f", "to_d");
   rb_define_method(cGMP_Q, "to_s", r_gmpq_to_s, 0);
   
   // Rational Arithmetic

data/manual.tex

@@ -169,7 +169,9 @@ In addition to the above three classes, there is also one constant within \textt
 
 \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:
+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)
@@ -180,4 +182,55 @@ GMP::Z.new(GMP::Z.new(31))  #=> 31          (GMP Integer)
 
 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.\\
+
+\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}
+
 \end{document}

data/test/README

@@ -22,8 +22,8 @@ Tests:
   14*   shifts, last_bits
   15*   logical tests, roots
   16*   floating point init with and without explicit precision
-  17    basic floating point arithmetics and coersion to F
-  18    default_prec and default_prec=
+  17*   basic floating point arithmetics and coersion to F
+  18*   default_prec and default_prec=
   19    integer division methods
   20    mpfr - exp and log
   21    mpfr - trigonometry

data/test/tc_f_arithmetics_coersion.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class TC_F_arithmetics_coersion < Test::Unit::TestCase
+  def setup
+    @a = GMP::F.new(3.14, 100)
+    @b = GMP::F.new(2.71, 200)
+    @c = GMP::Z(3)
+    @d = GMP::Q(7,2)
+    @e = 2**32
+  end
+  
+  def test_add
+    assert_in_delta(         5.85,   @a +   @b, 1e-6)
+    assert_in_delta(         5.85,   @b +   @a, 1e-6)
+    assert_in_delta(         6.14,   @a +   @c, 1e-6)
+    assert_in_delta(         6.14,   @c +   @a, 1e-6)
+    assert_in_delta(         6.64,   @a +   @d, 1e-6)
+    assert_in_delta(         6.64,   @d +   @a, 1e-6)
+    assert_in_delta(         5.14,   @a +    2, 1e-6)
+    assert_in_delta(         5.14,    2 +   @a, 1e-6)
+    assert_in_delta(4294967299.14,   @a +   @e, 1e-6)
+    assert_in_delta(4294967299.14,   @e +   @a, 1e-6)
+    assert_in_delta(         7.65,   @a + 4.51, 1e-6)
+    assert_in_delta(         7.65, 4.51 +   @a, 1e-6)
+  end
+  
+  def test_sub
+    assert_in_delta(          0.43,   @a -   @b, 1e-6)
+    assert_in_delta(         -0.43,   @b -   @a, 1e-6)
+    assert_in_delta(          0.14,   @a -   @c, 1e-6)
+    assert_in_delta(         -0.14,   @c -   @a, 1e-6)
+    assert_in_delta(         -0.36,   @a -   @d, 1e-6)
+    assert_in_delta(          0.36,   @d -   @a, 1e-6)
+    assert_in_delta(          1.14,   @a -    2, 1e-6)
+    assert_in_delta(         -1.14,    2 -   @a, 1e-6)
+    assert_in_delta(-4294967292.86,   @a -   @e, 1e-6)
+    assert_in_delta( 4294967292.86,   @e -   @a, 1e-6)
+    assert_in_delta(         -1.37,   @a - 4.51, 1e-6)
+    assert_in_delta(          1.37, 4.51 -   @a, 1e-6)
+  end
+  
+  def test_mul
+    assert_in_delta(          8.5094,   @a *   @b, 1e-6)
+    assert_in_delta(          8.5094,   @b *   @a, 1e-6)
+    assert_in_delta(          9.42  ,   @a *   @c, 1e-6)
+    assert_in_delta(          9.42  ,   @c *   @a, 1e-6)
+    assert_in_delta(         10.99  ,   @a *   @d, 1e-6)
+    assert_in_delta(         10.99  ,   @d *   @a, 1e-6)
+    assert_in_delta(          6.28  ,   @a *    2, 1e-6)
+    assert_in_delta(          6.28  ,    2 *   @a, 1e-6)
+    assert_in_delta(13486197309.44  ,   @a *   @e, 1e-6)
+    assert_in_delta(13486197309.44  ,   @e *   @a, 1e-6)
+    assert_in_delta(         14.1614,   @a * 4.51, 1e-6)
+    assert_in_delta(         14.1614, 4.51 *   @a, 1e-6)
+  end
+  
+  def test_div
+    assert_in_delta(          1.1586715867,   @a /   @b, 1e-6)
+    assert_in_delta(          0.8630573248,   @b /   @a, 1e-6)
+    assert_in_delta(          1.0466666667,   @a /   @c, 1e-6)
+    assert_in_delta(          0.9554140127,   @c /   @a, 1e-6)
+    assert_in_delta(          0.8971428571,   @a /   @d, 1e-6)
+    assert_in_delta(          1.1146496815,   @d /   @a, 1e-6)
+    assert_in_delta(          1.57        ,   @a /    2, 1e-6)
+    assert_in_delta(          0.6369426752,    2 /   @a, 1e-6)
+    assert_in_delta(          0.0000000007,   @a /   @e, 1e-6)
+    assert_in_delta( 1367823979.6178343949,   @e /   @a, 1e-6)
+    assert_in_delta(          0.6962305987,   @a / 4.51, 1e-6)
+    assert_in_delta(          1.4363057325, 4.51 /   @a, 1e-6)
+  end
+end

data/test/tc_f_precision.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class TC_precision < Test::Unit::TestCase
+  def setup
+    @pi = GMP::F.new(3.14)
+    @seven_halves = GMP::F.new(GMP::Q.new(7,2), 1000)
+  end
+  
+  def test_default_precision
+    assert_equal("0.e+0", GMP::F.new().to_s)
+    assert_equal(64,      GMP::F.new().prec)
+    assert_equal("0.314000000000000012434e+1", @pi.to_s)
+    assert_equal(64,                           @pi.prec)
+    assert_equal("0.1e+1", GMP::F.new(1).to_s)
+    assert_equal(64,       GMP::F.new(1).prec)
+    assert_equal("0.314e+1", GMP::F.new("3.14").to_s)
+    assert_equal(64,         GMP::F.new("3.14").prec)
+    assert_equal("0.4294967296e+10", GMP::F.new(2**32).to_s)
+    assert_equal(64,                 GMP::F.new(2**32).prec)
+    assert_equal("0.3e+1", GMP::F.new(GMP::Z.new(3)).to_s)
+    assert_equal(64,       GMP::F.new(GMP::Z.new(3)).prec)
+    assert_equal("0.35e+1", GMP::F.new(GMP::Q.new(7,2)).to_s)
+    assert_equal(64,        GMP::F.new(GMP::Q.new(7,2)).prec)
+    assert_equal("0.314000000000000012434e+1", GMP::F.new(@pi).to_s)
+    assert_equal(64,                           GMP::F.new(@pi).prec)
+  end
+  
+  def test_specific_precision
+    assert_equal("0.3140000000000000124344978758017532527446746826171875e+1", GMP::F.new(3.14, 1000).to_s)
+    assert_equal(1024,                                                        GMP::F.new(3.14, 1000).prec)
+    assert_equal("0.1e+1", GMP::F.new(1, 1000).to_s)
+    assert_equal(1024,     GMP::F.new(1, 1000).prec)
+    assert_equal("0.314e+1", GMP::F.new("3.14", 1000).to_s)
+    assert_equal(1024,       GMP::F.new("3.14", 1000).prec)
+    assert_equal("0.4294967296e+10", GMP::F.new(2**32, 1000).to_s)
+    assert_equal(1024,               GMP::F.new(2**32, 1000).prec)
+    assert_equal("0.3e+1", GMP::F.new(GMP::Z.new(3), 1000).to_s)
+    assert_equal(1024,     GMP::F.new(GMP::Z.new(3), 1000).prec)
+    assert_equal("0.35e+1", @seven_halves.to_s)
+    assert_equal(1024,      @seven_halves.prec)
+    assert_equal("0.35e+1", GMP::F.new(@seven_halves).to_s)
+    assert_equal(1024,      GMP::F.new(@seven_halves).prec)
+    assert_equal("0.3140000000000000124344978758017532527446746826171875e+1", GMP::F.new(@pi, 1000).to_s)
+    assert_equal(1024,                                                        GMP::F.new(@pi, 1000).prec)
+    assert_equal("0.35e+1", GMP::F.new(@seven_halves, 0).to_s)
+    assert_equal(64,        GMP::F.new(@seven_halves, 0).prec)
+  end
+end

data/test/unit_tests.rb

@@ -16,120 +16,84 @@ require 'tc_floor_ceil_truncate'
 require 'tc_z_to_d_to_i'
 require 'tc_z_shifts_last_bits'
 require 'tc_logical_roots'
+require 'tc_f_precision'
+require 'tc_f_arithmetics_coersion'
 
-class TC_precision < Test::Unit::TestCase
-  def setup
-    @pi = GMP::F.new(3.14)
-    @seven_halves = GMP::F.new(GMP::Q.new(7,2), 1000)
-  end
-  
-  def test_default_precision
-    assert_equal("0.e+0", GMP::F.new().to_s)
-    assert_equal(64,      GMP::F.new().prec)
-    assert_equal("0.314000000000000012434e+1", @pi.to_s)
-    assert_equal(64,                           @pi.prec)
-    assert_equal("0.1e+1", GMP::F.new(1).to_s)
-    assert_equal(64,       GMP::F.new(1).prec)
-    assert_equal("0.314e+1", GMP::F.new("3.14").to_s)
-    assert_equal(64,         GMP::F.new("3.14").prec)
-    assert_equal("0.4294967296e+10", GMP::F.new(2**32).to_s)
-    assert_equal(64,                 GMP::F.new(2**32).prec)
-    assert_equal("0.3e+1", GMP::F.new(GMP::Z.new(3)).to_s)
-    assert_equal(64,       GMP::F.new(GMP::Z.new(3)).prec)
-    assert_equal("0.35e+1", GMP::F.new(GMP::Q.new(7,2)).to_s)
-    assert_equal(64,        GMP::F.new(GMP::Q.new(7,2)).prec)
-    assert_equal("0.314000000000000012434e+1", GMP::F.new(@pi).to_s)
-    assert_equal(64,                           GMP::F.new(@pi).prec)
-  end
-  
-  def test_specific_precision
-    assert_equal("0.3140000000000000124344978758017532527446746826171875e+1", GMP::F.new(3.14, 1000).to_s)
-    assert_equal(1024,                                                        GMP::F.new(3.14, 1000).prec)
-    assert_equal("0.1e+1", GMP::F.new(1, 1000).to_s)
-    assert_equal(1024,     GMP::F.new(1, 1000).prec)
-    assert_equal("0.314e+1", GMP::F.new("3.14", 1000).to_s)
-    assert_equal(1024,       GMP::F.new("3.14", 1000).prec)
-    assert_equal("0.4294967296e+10", GMP::F.new(2**32, 1000).to_s)
-    assert_equal(1024,               GMP::F.new(2**32, 1000).prec)
-    assert_equal("0.3e+1", GMP::F.new(GMP::Z.new(3), 1000).to_s)
-    assert_equal(1024,     GMP::F.new(GMP::Z.new(3), 1000).prec)
-    assert_equal("0.35e+1", @seven_halves.to_s)
-    assert_equal(1024,      @seven_halves.prec)
-    assert_equal("0.35e+1", GMP::F.new(@seven_halves).to_s)
-    assert_equal(1024,      GMP::F.new(@seven_halves).prec)
-    assert_equal("0.3140000000000000124344978758017532527446746826171875e+1", GMP::F.new(@pi, 1000).to_s)
-    assert_equal(1024,                                                        GMP::F.new(@pi, 1000).prec)
-    assert_equal("0.35e+1", GMP::F.new(@seven_halves, 0).to_s)
-    assert_equal(64,        GMP::F.new(@seven_halves, 0).prec)
+class TC_default_prec < Test::Unit::TestCase
+  def test_default_prec
+    assert_equal( 64, GMP::F.default_prec, "GMP::F.default_prec should be 64.")
+    GMP::F.default_prec = 100
+    assert_equal(128, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
+    GMP::F.default_prec =  64
   end
 end
 
-class TC_F_arithmetics_coersion < Test::Unit::TestCase
+class TC_division < Test::Unit::TestCase
   def setup
-    @a = GMP::F.new(3.14, 100)
-    @b = GMP::F.new(2.71, 200)
-    @c = GMP::Z(3)
-    @d = GMP::Q(7,2)
-    @e = 2**32
+    @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_add
-    assert_in_delta(         5.85,   @a +   @b, 1e-6)
-    assert_in_delta(         5.85,   @b +   @a, 1e-6)
-    assert_in_delta(         6.14,   @a +   @c, 1e-6)
-    assert_in_delta(         6.14,   @c +   @a, 1e-6)
-    assert_in_delta(         6.64,   @a +   @d, 1e-6)
-    assert_in_delta(         6.64,   @d +   @a, 1e-6)
-    assert_in_delta(         5.14,   @a +    2, 1e-6)
-    assert_in_delta(         5.14,    2 +   @a, 1e-6)
-    assert_in_delta(4294967299.14,   @a +   @e, 1e-6)
-    assert_in_delta(4294967299.14,   @e +   @a, 1e-6)
-    assert_in_delta(         7.65,   @a + 4.51, 1e-6)
-    assert_in_delta(         7.65, 4.51 +   @a, 1e-6)
+  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_sub
-    assert_in_delta(          0.43,   @a -   @b, 1e-6)
-    assert_in_delta(         -0.43,   @b -   @a, 1e-6)
-    assert_in_delta(          0.14,   @a -   @c, 1e-6)
-    assert_in_delta(         -0.14,   @c -   @a, 1e-6)
-    assert_in_delta(         -0.36,   @a -   @d, 1e-6)
-    assert_in_delta(          0.36,   @d -   @a, 1e-6)
-    assert_in_delta(          1.14,   @a -    2, 1e-6)
-    assert_in_delta(         -1.14,    2 -   @a, 1e-6)
-    assert_in_delta(-4294967292.86,   @a -   @e, 1e-6)
-    assert_in_delta( 4294967292.86,   @e -   @a, 1e-6)
-    assert_in_delta(         -1.37,   @a - 4.51, 1e-6)
-    assert_in_delta(          1.37, 4.51 -   @a, 1e-6)
+  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_mul
-    assert_in_delta(          8.5094,   @a *   @b, 1e-6)
-    assert_in_delta(          8.5094,   @b *   @a, 1e-6)
-    assert_in_delta(          9.42  ,   @a *   @c, 1e-6)
-    assert_in_delta(          9.42  ,   @c *   @a, 1e-6)
-    assert_in_delta(         10.99  ,   @a *   @d, 1e-6)
-    assert_in_delta(         10.99  ,   @d *   @a, 1e-6)
-    assert_in_delta(          6.28  ,   @a *    2, 1e-6)
-    assert_in_delta(          6.28  ,    2 *   @a, 1e-6)
-    assert_in_delta(13486197309.44  ,   @a *   @e, 1e-6)
-    assert_in_delta(13486197309.44  ,   @e *   @a, 1e-6)
-    assert_in_delta(         14.1614,   @a * 4.51, 1e-6)
-    assert_in_delta(         14.1614, 4.51 *   @a, 1e-6)
+  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_div
-    assert_in_delta(          1.1586715867,   @a /   @b, 1e-6)
-    assert_in_delta(          0.8630573248,   @b /   @a, 1e-6)
-    assert_in_delta(          1.0466666667,   @a /   @c, 1e-6)
-    assert_in_delta(          0.9554140127,   @c /   @a, 1e-6)
-    assert_in_delta(          0.8971428571,   @a /   @d, 1e-6)
-    assert_in_delta(          1.1146496815,   @d /   @a, 1e-6)
-    assert_in_delta(          1.57        ,   @a /    2, 1e-6)
-    assert_in_delta(          0.6369426752,    2 /   @a, 1e-6)
-    assert_in_delta(          0.0000000007,   @a /   @e, 1e-6)
-    assert_in_delta( 1367823979.6178343949,   @e /   @a, 1e-6)
-    assert_in_delta(          0.6962305987,   @a / 4.51, 1e-6)
-    assert_in_delta(          1.4363057325, 4.51 /   @a, 1e-6)
+  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
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gmp
 version: !ruby/object:Gem::Version 
-  version: 0.1.7
+  version: 0.1.8
 platform: ruby
 authors: 
 - Tomasz Wegrzanowski
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-01 00:00:00 -07:00
+date: 2009-10-20 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -37,6 +37,8 @@ files:
 - ext/takeover.h
 - test/README
 - test/tc_cmp.rb
+- test/tc_f_precision.rb
+- test/tc_f_arithmetics_coersion.rb
 - test/tc_fib_fac_nextprime.rb
 - test/tc_floor_ceil_truncate.rb
 - test/tc_logical_roots.rb
@@ -58,7 +60,7 @@ files:
 - README.rdoc
 - manual.tex
 has_rdoc: false
-homepage: http://github.com/srawlins/gmp/tree/master
+homepage: http://github.com/srawlins/gmp
 licenses: []
 
 post_install_message: