gmp 0.4.0-x86-mingw32

data/test/tc_q.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class TC_Q < Test::Unit::TestCase
+  def test_init_null
+    assert_equal(GMP::Q.new(), 0, "GMP::Q.new() should initialize to 0")
+  end
+
+  def test_init_fixnum
+    assert_equal(GMP::Q.new(1), 1, "GMP::Q.new(x : Fixnum) should initialize to 0")
+  end
+
+  def test_init_fixnum2
+    assert_equal(GMP::Q.new(1, 2).to_s, "1/2", "GMP::Q.new(num : Fixnum, den : Fixnum) should initialize to num/den")
+    assert_equal(GMP::Q.new(1, 3).to_s, "1/3", "GMP::Q.new(num : Fixnum, den : Fixnum) should initialize to num/den")
+    assert_equal(GMP::Q.new(2, 4).to_s, "1/2", "GMP::Q.new(num : Fixnum, den : Fixnum) should initialize to num/den")
+  end
+
+  def test_init_string
+    assert_equal(GMP::Q.new("1/2").to_s, "1/2", "GMP::Q.new(x : String) should initialize to x")
+    assert_equal(GMP::Q.new("1/3").to_s, "1/3", "GMP::Q.new(x : String) should initialize to x")
+  end
+
+  def test_init_q
+    a = GMP::Q.new(1,2)
+    assert_equal(GMP::Q.new(a), a, "GMP::Q.new(x : Q) should initialize to x")
+  end
+end

data/test/tc_q_basic.rb

@@ -0,0 +1,41 @@
+require 'test_helper'
+
+# [Q op Q, Q op Z, Z op Q, Q op FixNum, Q op BigNum, FixNum op Q, BigNum op Q]
+class TC_Q_Basic < Test::Unit::TestCase
+  def setup
+    @a=GMP::Q.new(100,11)
+    @b=GMP::Q.new(200,17)
+    @c=GMP::Z.new(40)
+    @d=2**32
+  end
+
+  def test_add
+    assert_equal(@a + @b, GMP::Q(3900, 187),       "GMP::Q should add GMP::Q correctly")
+    assert_equal(@a + @c, GMP::Q(540,  11),        "GMP::Q should add GMP::Z correctly")
+    assert_equal(@c + @a, GMP::Q(540,  11),        "GMP::Z should add GMP::Q correctly")
+    assert_equal(@a +  2, GMP::Q(122,  11),        "GMP::Z should add Fixnum correctly")
+    assert_equal(@a + @d, GMP::Q(47244640356, 11), "GMP::Z should add Bignum correctly")
+    assert_equal( 2 + @a, GMP::Q(122,  11),        "Fixnum should add GMP::Q correctly")
+    assert_equal(@d + @a, GMP::Q(47244640356, 11), "Bignum should add GMP::Q correctly")
+  end
+
+  def test_sub
+    assert_equal(@a - @b, GMP::Q(-500, 187),       "GMP::Q should subtract GMP::Q correctly")
+    assert_equal(@a - @c, GMP::Q(-340, 11),        "GMP::Q should subtract GMP::Z correctly")
+    assert_equal(@c - @a, GMP::Q(340,  11),        "GMP::Z should subtract GMP::Q correctly")
+    assert_equal(@a -  2, GMP::Q(78,  11),         "GMP::Z should subtract Fixnum correctly")
+    assert_equal(@a - @d, GMP::Q(-47244640156, 11),"GMP::Z should subtract Bignum correctly")
+    assert_equal( 2 - @a, GMP::Q(-78,  11),        "Fixnum should subtract GMP::Q correctly")
+    assert_equal(@d - @a, GMP::Q(47244640156, 11), "Bignum should subtract GMP::Q correctly")
+  end
+
+  def test_mul
+    assert_equal(@a * @b, GMP::Q(20000, 187),      "GMP::Q should multiply GMP::Q correctly")
+    assert_equal(@a * @c, GMP::Q(4000,  11),       "GMP::Q should multiply GMP::Z correctly")
+    assert_equal(@c * @a, GMP::Q(4000,  11),       "GMP::Z should multiply GMP::Q correctly")
+    assert_equal(@a *  2, GMP::Q(200,  11),        "GMP::Z should multiply Fixnum correctly")
+    # assert_equal(@a * @d, GMP::Q(429496729600, 11),"GMP::Z should multiply Bignum correctly")  # SEGFAULT
+    assert_equal( 2 * @a, GMP::Q(200,  11),        "Fixnum should multiply GMP::Q correctly")
+    # assert_equal(@d * @a, GMP::Q(429496729600, 11),"Bignum should multiply GMP::Q correctly")  # SEGFAULT
+  end
+end

data/test/tc_random.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class TC_Random < Test::Unit::TestCase
+  def setup
+  end
+
+  def test_urandomb
+    @a = GMP::RandState.new
+    @a.seed(13579)
+    g1 = [ 392,  507, 1657, 3963, 2275, 1264, 2370, 2152, 3282,  407,
+          1746, 2488, 1753, 1639,  721, 3291, 3697, 2258, 3990, 1019]
+    g1.size.times do |i|
+      assert_equal(g1[i], @a.urandomb(12), "GMP::RandState should urandomb predictably.")
+    end
+    
+    @b = GMP::RandState.new
+    @b.seed(314159)
+    g2 = [   20,     5,    40,    228,    223,    205,   1750,    690,    5794,   13752,
+          31377, 49064, 37010, 187285, 489973, 312091, 550520, 916752, 3213943, 1561294]
+    g2.size.times do |i|
+      assert_equal(g2[i], @b.urandomb(i+5), "GMP::RandState should urandomb predictably.")
+    end
+  end
+  
+  def test_reseed
+    @c = GMP::RandState.new
+    @c.seed(1000)
+    assert_equal( 6461, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+    assert_equal(42961, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+    assert_equal(44699, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+    @c.seed(1000)
+    assert_equal( 6461, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+    assert_equal(42961, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+    assert_equal(44699, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+    @c.seed(1000)
+    assert_equal( 6461, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+    assert_equal(42961, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+    assert_equal(44699, @c.urandomb(16), "GMP::RandState should re-seed correctly.")
+  end
+  
+  def test_random_independent_states
+    @d = GMP::RandState.new
+    @d.seed(13579)
+    @e = GMP::RandState.new
+    @e.seed(13579)
+    
+    assert_equal( 392, @d.urandomb(12), "GMP::RandState should be independent correctly.")
+    assert_equal( 507, @d.urandomb(12), "GMP::RandState should be independent correctly.")
+    assert_equal( 392, @e.urandomb(12), "GMP::RandState should be independent correctly.")
+    assert_equal( 507, @e.urandomb(12), "GMP::RandState should be independent correctly.")
+    assert_equal(1657, @d.urandomb(12), "GMP::RandState should be independent correctly.")
+    assert_equal(1657, @e.urandomb(12), "GMP::RandState should be independent correctly.")
+  end
+end

data/test/tc_sgn_neg_abs.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class TC_sgn_neg_abs < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(10)
+    @b=GMP::Z.new()
+    @c=GMP::Z.new(-10)
+    @d=GMP::Q.new(10)
+    @e=GMP::Q.new()
+    @f=GMP::Q.new(-10)
+    @k=GMP::Z.new(10)
+    @l=GMP::Z.new()
+    @m=GMP::Z.new(-10)
+    @n=GMP::Q.new(10)
+    @o=GMP::Q.new()
+    @p=GMP::Q.new(-10)
+  end
+  
+  def test_sgn
+    assert_equal([1, 0, 1, 0], [@a.sgn, @b.sgn, @d.sgn, @e.sgn], "GMP::Z, GMP::Q should calculate sgn correctly")
+    assert_equal([-1, -1],     [@c.sgn, @f.sgn],                 "GMP::Z, GMP::Q should calculate sgn correctly")
+  end
+  
+  def test_neg
+    assert_equal(-@a, @c,                                        "-(x : GMP::Z) should be calculated correctly.")
+    assert_equal(-@c, @a,                                        "-(x : GMP::Z) should be calculated correctly.")
+    assert_equal(-@b, @b,                                        "-GMP::Z.new() should equal GMP::Z.new().")
+    assert_equal(-@d, @f,                                        "-(x : GMP::Q) should be calculated correctly.")
+    assert_equal(-@f, @d,                                        "-(x : GMP::Q) should be calculated correctly.")
+    assert_equal(-@e, @e,                                        "-GMP::Q.new() should equal GMP::Q.new().")
+    @k.neg!; @l.neg!; @m.neg!; @n.neg!; @o.neg!; @p.neg!
+    assert_equal(@k, @c,                                         "(x : GMP::Z).neg! should be calculated correctly.")
+    assert_equal(@l, @b,                                         "(x : GMP::Z).neg! should be calculated correctly.")
+    assert_equal(@m, @a,                                         "GMP::Z.new().neg! should equal GMP::Z.new().")
+    assert_equal(@n, @f,                                         "(x : GMP::Q).neg! should be calculated correctly.")
+    assert_equal(@o, @e,                                         "(x : GMP::Q).neg! should be calculated correctly.")
+    assert_equal(@p, @d,                                         "GMP::Q.new().neg! should equal GMP::Q.new().")
+  end
+  
+  def test_abs
+    assert_equal([10, 0, 10], [@a.abs, @b.abs, @c.abs],          "(x : GMP::Z).abs should be calculated correctly.")
+    assert_equal([10, 0, 10], [@d.abs, @e.abs, @f.abs],          "(x : GMP::Q).abs should be calculated correctly.")
+    @a.abs!; @b.abs!; @c.abs!; @d.abs!; @e.abs!; @f.abs!
+    assert_equal([10, 0, 10], [@a, @b, @c],                      "(x : GMP::Z).abs! should be calculated correctly.")
+    assert_equal([10, 0, 10], [@d, @e, @f],                      "(x : GMP::Q).abs! should be calculated correctly.")
+  end
+end

data/test/tc_swap.rb

@@ -0,0 +1,19 @@
+require 'test_helper'
+
+class TC_swap < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(100)
+    @b=GMP::Z.new(200)
+    @c=GMP::Q.new(100,11)
+    @d=GMP::Q.new(200,17)
+  end
+  
+  def test_swap
+    @a.swap @b
+    @c.swap @d
+    assert_equal(@a, 200, "GMP::Z should swap with GMP::Z.")
+    assert_equal(@b, 100, "GMP::Z should swap with GMP::Z.")
+    assert_equal(@c, GMP::Q.new(200,17), "GMP::Z should swap with GMP::Z.")
+    assert_equal(@d, GMP::Q.new(100,11), "GMP::Z should swap with GMP::Z.")
+  end
+end

data/test/tc_z.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+class TC_Z < Test::Unit::TestCase
+  def test_init_null
+    assert_equal(GMP::Z.new(), 0, "GMP::Z.new() should initialize to 0")
+  end
+
+  def test_init_fixnum
+    assert_equal(GMP::Z.new(1), 1, "GMP::Z.new(x : Fixnum) should initialize to x")
+  end
+
+  def test_init_z
+    b = GMP::Z.new(1)
+    assert_equal(GMP::Z.new(b), b, "GMP::Z.new(x : GMP::Z) should initialize to x")
+  end
+
+  def test_init_string
+    assert_equal(GMP::Z.new("1"), 1, "GMP::Z.new(x : String) should initialize to x")
+  end
+
+  def test_init_bignum
+    assert_equal(GMP::Z.new(2**32), 2**32, "GMP::Z.new(x : Bignum) should initialize to x")
+  end
+
+  def test_cmp_z
+    a = GMP::Z.new(2)
+    b = GMP::Z.new(1)
+    assert_equal(a >  b, true,  "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(a >  a, false, "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(b >  a, false, "GMP::Z should compare correctly with GMP::Z")
+
+    assert_equal(a >= b, true,  "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(a >= a, true,  "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(b >= a, false, "GMP::Z should compare correctly with GMP::Z")
+
+    assert_equal(a <= b, false, "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(a <= a, true,  "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(b <= a, true,  "GMP::Z should compare correctly with GMP::Z")
+
+    assert_equal(a <  b, false, "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(a <  a, false, "GMP::Z should compare correctly with GMP::Z")
+    assert_equal(b <  a, true,  "GMP::Z should compare correctly with GMP::Z")
+
+    assert_equal(a == b, false, "GMP::Z should == correctly with GMP::Z")
+    assert_equal(a == a, true,  "GMP::Z should == correctly with GMP::Z")
+
+    assert_equal(a != b, true,  "GMP::Z should != correctly with GMP::Z")
+    assert_equal(a != a, false, "GMP::Z should != correctly with GMP::Z")
+
+    assert_equal(a <=> b,  1, "GMP::Z should <=> correctly with GMP::Z")
+    assert_equal(a <=> a,  0, "GMP::Z should <=> correctly with GMP::Z")
+    assert_equal(b <=> a, -1, "GMP::Z should <=> correctly with GMP::Z")
+  end
+
+  def test_to_s
+    assert_equal("1",          GMP::Z.new(1).to_s,          "Z(1).to_s should equal '1'")
+    assert_equal("-1",         GMP::Z.new(-1).to_s,         "Z(1).to_s should equal '-1'")
+    assert_equal("1234567890", GMP::Z.new(1234567890).to_s, "GMP::Z should to_s correctly.")
+    assert_equal("100000",     GMP::Z.new(32).to_s(   2),   "GMP::Z should to_s(   2) correctly.")
+    assert_equal("200",        GMP::Z.new(32).to_s(   4),   "GMP::Z should to_s(   4) correctly.")
+    assert_equal("40",         GMP::Z.new(32).to_s(   8),   "GMP::Z should to_s(   8) correctly.")
+    assert_equal("32",         GMP::Z.new(32).to_s(  10),   "GMP::Z should to_s(  10) correctly.")
+    assert_equal("20",         GMP::Z.new(32).to_s(  16),   "GMP::Z should to_s(  16) correctly.")
+    assert_equal("a",          GMP::Z.new(10).to_s(  16),   "GMP::Z should to_s(  16) correctly.")
+    assert_equal("A",          GMP::Z.new(10).to_s( -16),   "GMP::Z should to_s( -16) correctly.")
+    assert_equal("11111111",   GMP::Z.new(255).to_s(:bin),  "GMP::Z should to_s(:bin) correctly.")
+    assert_equal("377",        GMP::Z.new(255).to_s(:oct),  "GMP::Z should to_s(:oct) correctly.")
+    assert_equal("255",        GMP::Z.new(255).to_s(:dec),  "GMP::Z should to_s(:dec) correctly.")
+    assert_equal("ff",         GMP::Z.new(255).to_s(:hex),  "GMP::Z should to_s(:hex) correctly.")
+  end
+end

data/test/tc_z_basic.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+# Tested: [Z op Z, Z op FixNum, Z op BigNum, FixNum op Z, BigNum op Z]
+# Things are tested both ways because the implementation is asymetrical
+class TC_Z_Basic < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(100)
+    @b=GMP::Z.new(200)
+    @c=2**32
+  end
+
+  def test_add
+    assert_equal(@a + @b, 100   + 200,   "GMP::Z should add correctly")
+    assert_equal(@a + 2,  100   + 2,     "GMP::Z should add correctly")
+    assert_equal(@a + @c, 100   + 2**32, "GMP::Z should add correctly")
+    assert_equal( 2 + @a, 2     + 100,   "GMP::Z should add correctly")
+    assert_equal(@c + @a, 2**32 + 100,   "GMP::Z should add correctly")
+  end
+
+  def test_sub
+    assert_equal(@a - @b, 100   - 200,   "GMP::Z should subtract correctly")
+    assert_equal(@a - 2,  100   - 2,     "GMP::Z should subtract correctly")
+    assert_equal(@a - @c, 100   - 2**32, "GMP::Z should subtract correctly")
+    assert_equal( 2 - @a, 2     - 100,   "GMP::Z should subtract correctly")
+    assert_equal(@c - @a, 2**32 - 100,   "GMP::Z should subtract correctly")
+  end
+
+  def test_mul
+    assert_equal(@a * @b, 100   * 200,   "GMP::Z should multiply correctly")
+    assert_equal(@a * 2,  100   * 2,     "GMP::Z should multiply correctly")
+    assert_equal(@a * @c, 100   * 2**32, "GMP::Z should multiply correctly")
+    assert_equal( 2 * @a, 2     * 100,   "GMP::Z should multiply correctly")
+    assert_equal(@c * @a, 2**32 * 100,   "GMP::Z should multiply correctly")
+  end
+end

data/test/tc_z_exponentiation.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class TC_Z_Exponentiation < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z.new(100)
+    @b = GMP::Z.new(16)
+    @c = @a**5
+  end
+  
+  def test_exponentiation
+    assert_equal(GMP::Z(10000000000), @a**5,                          "GMP::Z should **(Fixnum) correctly")
+    assert_equal(GMP::Z("100000000000000000000000000000000"), @a**@b, "GMP::Z should **(GMP::Z) correctly")
+    assert_equal(GMP::Z(65536), 2**@b,                                "Fixnum should **(GMP::Z) correctly")
+  end
+  
+  def test_powmod
+    assert_equal(GMP::Z(16), @a.powmod(2,256),  "(a : GMP::Z).powmod((b : Fixnum), (c : Fixnum)) should work correctly")
+    assert_equal(GMP::Z(76), @b.powmod(10,@a),  "(a : GMP::Z).powmod((b : Fixnum), (c : GMP::Z)) should work correctly")
+    assert_equal(GMP::Z(0), @a.powmod(@b,256),  "(a : GMP::Z).powmod((b : GMP::Z), (c : Fixnum)) should work correctly")
+    assert_equal(GMP::Z(0), @a.powmod(@b,@c), "(a : GMP::Z).powmod((b : GMP::Z), (c : GMP::Z)) should work correctly")
+  end
+end

data/test/tc_z_gcd_lcm_invert.rb

@@ -0,0 +1,57 @@
+require 'test_helper'
+
+class TC_Z_GCD_LCM_Invert < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z( 24)  # 2^3 * 3
+    @b = GMP::Z(  8)  # 2^3
+    @c = GMP::Z(  3)  # 3
+    @d = GMP::Z(  7)  # 7
+    @e = GMP::Z( 11)  # 11
+    @f = GMP::Z( 25)  # 25
+    @g = GMP::Z(720)  # 2^4 * 3^2 * 5 = 1*2*3*4*5*6
+  end
+
+  def test_gcd
+    assert_equal(GMP::Z( 8), @a.gcd(@b), "GMP::Z should gcd correctly")
+    assert_equal(GMP::Z( 3), @a.gcd(@c), "GMP::Z should gcd correctly")
+    assert_equal(GMP::Z( 1), @c.gcd(@d), "GMP::Z should gcd correctly")
+    assert_equal(GMP::Z( 1), @a.gcd(@f), "GMP::Z should gcd correctly")
+    assert_equal(GMP::Z(24), @a.gcd(@g), "GMP::Z should gcd correctly")
+  end
+  
+  def test_gcd2
+    assert_equal(GMP::Z( 8), (-@a).gcd(@b), "GMP::Z should gcd negatives correctly")
+    assert_equal(GMP::Z( 3), (-@a).gcd(@c), "GMP::Z should gcd negatives correctly")
+    assert_equal(GMP::Z( 1), (-@c).gcd(@d), "GMP::Z should gcd correctly")
+    assert_equal(GMP::Z(24), (-@a).gcd(@g), "GMP::Z should gcd correctly")
+    
+    assert_equal(GMP::Z( 8), @a.gcd(-@b), "GMP::Z should gcd negatives correctly")
+    assert_equal(GMP::Z( 3), @a.gcd(-@c), "GMP::Z should gcd negatives correctly")
+    assert_equal(GMP::Z( 1), @c.gcd(-@d), "GMP::Z should gcd correctly")
+    assert_equal(GMP::Z(24), @a.gcd(-@g), "GMP::Z should gcd correctly")
+    
+    assert_equal(GMP::Z( 8), (-@a).gcd(-@b), "GMP::Z should gcd negatives correctly")
+    assert_equal(GMP::Z( 3), (-@a).gcd(-@c), "GMP::Z should gcd negatives correctly")
+    assert_equal(GMP::Z( 1), (-@c).gcd(-@d), "GMP::Z should gcd correctly")
+    assert_equal(GMP::Z(24), (-@a).gcd(-@g), "GMP::Z should gcd correctly")
+  end
+  
+  def test_invert
+    assert_equal(GMP::Z( 1), GMP::Z( 1).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 6), GMP::Z( 2).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 4), GMP::Z( 3).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 3), GMP::Z( 4).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 9), GMP::Z( 5).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 2), GMP::Z( 6).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 8), GMP::Z( 7).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 7), GMP::Z( 8).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 5), GMP::Z( 9).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z(10), GMP::Z(10).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 0), GMP::Z(11).invert(@e), "GMP::Z should invert correctly")
+    
+    assert_equal(GMP::Z( 1), GMP::Z(12).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 6), GMP::Z(13).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 4), GMP::Z(14).invert(@e), "GMP::Z should invert correctly")
+    assert_equal(GMP::Z( 3), GMP::Z(15).invert(@e), "GMP::Z should invert correctly")
+  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