gmp 0.4.0-x86-mingw32

data/test/README

@@ -0,0 +1,34 @@
+Tests:
+   1*   initializations and to_s
+   2*   basic integer arithmetics and coersion to Z
+   3*   integer logical operators
+   4*   comparisions between Z, Q, FixNum and BigNum
+   5*   basic rational arithmetics and coersion to Q
+   6    bit operations, scan0, scan1
+   7*   exponentiation and exponentiation modulo
+   8*   divide by zero exceptions
+   9*   sgn, neg, abs
+  10*   fibonacci, factorial, nextprime
+  11*   swap
+  12*   floor, ceil, truncate
+  13*   to_i, to_d
+  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=
+  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
+  25*   gcd, gcdext, lcm, invert
+TODO:
+  gcd, lcm
+  cmpabs
+  integer and integer->rational division, modulo
+  more number theoretic functions
+  random numbers
+  range errors
+  full coverage?

data/test/tc_cmp.rb

@@ -0,0 +1,74 @@
+require 'test_helper'
+
+class TC_Cmp < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(180)
+    @c=GMP::Q.new(2000,11) # ~181.82
+    @d=GMP::Q.new(3000,17) # ~176.47
+    @e=700
+    @f=2**32
+    @g=GMP::Q(360,2)
+  end
+
+  def test_cmp_q_q
+    assert_equal(@c >  @d, true,  "GMP::Q should compare correctly")
+    assert_equal(@c >= @d, true,  "GMP::Q should compare correctly")
+    assert_equal(@c <  @d, false, "GMP::Q should compare correctly")
+    assert_equal(@c <= @d, false, "GMP::Q should compare correctly")
+    assert_equal(@c == @d, false, "GMP::Q should == correctly")
+    assert_equal(@c == @c, true,  "GMP::Q should == correctly")
+    assert_equal(@c != @d, true,  "GMP::Q should != correctly")
+    assert_equal(@c != @c, false, "GMP::Q should != correctly")
+
+    assert_equal(@c <=> @d,  1, "GMP::Q should <=> correctly")
+    assert_equal(@c <=> @c,  0, "GMP::Q should <=> correctly")
+    assert_equal(@d <=> @c, -1, "GMP::Q should <=> correctly")
+  end
+
+  def test_cmp_q_z
+    assert_equal(@c >  @a, true,  "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@c >= @a, true,  "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@c <  @a, false, "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@c <= @a, false, "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@c == @a, false, "GMP::Q should == correctly with GMP::Z")
+    assert_equal(@c != @a, true,  "GMP::Q should != correctly with GMP::Z")
+
+    assert_equal(@a <  @c, true,  "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a <= @c, true,  "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a >  @c, false, "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a >= @c, false, "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a == @c, false, "GMP::Z should == correctly with GMP::Q")
+    assert_equal(@a != @c, true,  "GMP::Z should != correctly with GMP::Q")
+
+    assert_equal(@g == @a, true,  "GMP::Q should == correctly with GMP::Z")
+    assert_equal(@g != @a, false, "GMP::Q should != correctly with GMP::Z")
+
+    assert_equal(@d >  @a, false, "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@d >= @a, false, "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@d <  @a, true,  "GMP::Q should compare correctly with GMP::Z")
+    assert_equal(@d <= @a, true,  "GMP::Q should compare correctly with GMP::Z")
+
+    assert_equal(@a <  @d, false, "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a <= @d, false, "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a >  @d, true,  "GMP::Z should compare correctly with GMP::Q")
+    assert_equal(@a >= @d, true,  "GMP::Z should compare correctly with GMP::Q")
+
+    assert_equal(@c <=> @a,  1, "GMP::Q should <=> correctly with GMP::Z")
+    assert_equal(@g <=> @a,  0, "GMP::Q should <=> correctly with GMP::Z")
+    assert_equal(@a <=> @c, -1, "GMP::Q should <=> correctly with GMP::Z")
+  end
+
+  def test_cmp_z_int
+    assert_equal(@a <=> @e, -1, "GMP::Z should <=> correctly with Fixnum")
+    assert_equal(@e <=> @a,  1, "Fixnum should <=> correctly with GMP::Z")
+    assert_equal(@a <=> @f, -1, "GMP::Z should <=> correctly with Bignum")
+    assert_equal(@f <=> @a,  1, "Bignum should <=> correctly with GMP::Z")
+  end
+
+  def test_cmp_q_int
+    assert_equal(@c <=> @e, -1, "GMP::Q should <=> correctly with Fixnum")
+    assert_equal(@e <=> @c,  1, "Fixnum should <=> correctly with GMP::Q")
+    assert_equal(@c <=> @f, -1, "GMP::Q should <=> correctly with Bignum")
+    assert_equal(@f <=> @c,  1, "Bignum should <=> correctly with GMP::Q")
+  end
+end

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

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/tc_fib_fac_nextprime.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+class TC_fib_fac_nextprime < Test::Unit::TestCase
+  def setup
+    @z10 = GMP::Z.new(10)
+     @z7 = GMP::Z.new( 7)
+     @z8 = GMP::Z.new( 8)
+    @z11 = GMP::Z.new(11)
+    @z13 = GMP::Z.new(13)
+    @z17 = GMP::Z.new(17)
+    @z19 = GMP::Z.new(19)
+  end
+  
+  def test_fib
+    assert_equal(  1, GMP::Z.fib(   1), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  1, GMP::Z.fib(   2), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  2, GMP::Z.fib(   3), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  3, GMP::Z.fib(   4), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  5, GMP::Z.fib(   5), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(  8, GMP::Z.fib(   6), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 13, GMP::Z.fib(   7), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 21, GMP::Z.fib(   8), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 34, GMP::Z.fib(   9), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 55, GMP::Z.fib(  10), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal( 55, GMP::Z.fib(@z10), "GMP::Z::fib(x : GMP::Z) should be calculated correctly.")
+    assert_equal( 89, GMP::Z.fib(  11), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(144, GMP::Z.fib(  12), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(233, GMP::Z.fib(  13), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+    assert_equal(377, GMP::Z.fib(  14), "GMP::Z::fib(x : Fixnum) should be calculated correctly.")
+  end
+  
+  def test_fac
+    assert_equal(   1, GMP::Z.fac( 0), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(   1, GMP::Z.fac( 1), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(   2, GMP::Z.fac( 2), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(   6, GMP::Z.fac( 3), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(  24, GMP::Z.fac( 4), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal( 120, GMP::Z.fac( 5), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal( 720, GMP::Z.fac( 6), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+    assert_equal(5040, GMP::Z.fac( 7), "GMP::Z::fac(x : Fixnum) should be calculated correctly.")
+  end
+
+  def test_nextprime
+    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_floor_ceil_truncate.rb

@@ -0,0 +1,21 @@
+require 'test_helper'
+
+class TC_floor_ceil_truncate < Test::Unit::TestCase
+  def setup
+    @a = GMP::Q.new(200,11)
+    @b = -@a
+    @c = GMP::Q.new(70,10)
+  end
+  
+  def test_floor_ceil_truncate
+    assert_equal(@a.floor, 18, "GMP::Q should floor.")
+    assert_equal(@a.ceil, 19, "GMP::Q should ceil.")
+    assert_equal(@a.trunc, 18, "GMP::Q should truncate.")
+    assert_equal(@b.floor, -19, "GMP::Q (negative) should floor.")
+    assert_equal(@b.ceil, -18, "GMP::Q (negative) should ceil.")
+    assert_equal(@b.trunc, -18, "GMP::Q (negative) should truncate.")
+    assert_equal(@c.floor, 7, "GMP::Q (integer) should floor.")
+    assert_equal(@c.ceil, 7, "GMP::Q (integer) should ceil.")
+    assert_equal(@c.trunc, 7, "GMP::Q (integer) should truncate.")
+  end
+end

data/test/tc_logical_roots.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+
+class TC_logical_roots < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z.new(100)
+    @b = GMP::Z.new( 27)
+    @c = GMP::Z.new( 99)
+  end
+  
+  def test_parity
+    assert  @a.even?, "GMP::Z should even? correctly."
+    assert !@b.even?, "GMP::Z should even? correctly."
+    assert !@c.even?, "GMP::Z should even? correctly."
+    assert !@a.odd?,  "GMP::Z should odd? correctly."
+    assert  @b.odd?,  "GMP::Z should odd? correctly."
+    assert  @c.odd?,  "GMP::Z should odd? correctly."
+  end
+  
+  def test_square
+    assert  @a.square?, "GMP::Z should square? correctly."
+    assert !@b.square?, "GMP::Z should square? correctly."
+    assert !@c.square?, "GMP::Z should square? correctly."
+  end
+  
+  def test_power
+    assert  @a.power?, "GMP::Z should power? correctly."
+    assert  @b.power?, "GMP::Z should power? correctly."
+    assert !@c.power?, "GMP::Z should power? correctly."
+  end
+  
+  def sqrtrem
+    assert_equal([10,  0], @a.sqrtrem, "GMP::Z should sqrtrem correctly.")
+    assert_equal([ 5,  2], @b.sqrtrem, "GMP::Z should sqrtrem correctly.")
+    assert_equal([ 9, 18], @c.sqrtrem, "GMP::Z should sqrtrem correctly.")
+  end
+  
+  def sqrt
+    assert_equal(10, @a.sqrt, "GMP::Z should sqrt correctly.")
+    assert_equal( 5, @b.sqrt, "GMP::Z should sqrt correctly.")
+    assert_equal( 9, @c.sqrt, "GMP::Z should sqrt correctly.")
+  end
+  
+  def root
+    assert_equal(4, @a.root(3), "GMP::Z should root correctly.")
+    assert_equal(3, @b.root(3), "GMP::Z should root correctly.")
+    assert_equal(4, @c.root(3), "GMP::Z should root correctly.")
+  end
+end