gmp 0.5.3 → 0.5.23

data/test/tc_q.rb

@@ -23,6 +23,86 @@ class TC_Q < Test::Unit::TestCase
     assert_equal(GMP::Q.new(a), a, "GMP::Q.new(x : Q) should initialize to x")
   end
   
+  def test_neg
+        a = GMP::Q( 1,2)
+    neg_a = GMP::Q(-1,2)
+    assert_equal(neg_a, -a,     "GMP::Q#-@ should work.")
+    assert_equal(neg_a,  a.neg, "GMP::Q#neg should work.")
+    a.neg!
+    assert_equal(neg_a,  a,     "GMP::Q#neg! should work.")
+    
+        b = GMP::Q(-4,3)
+    neg_b = GMP::Q( 4,3)
+    assert_equal(neg_b, -b,     "GMP::Q#-@ should work.")
+    assert_equal(neg_b,  b.neg, "GMP::Q#neg should work.")
+    b.neg!
+    assert_equal(neg_b,  b,     "GMP::Q#neg! should work.")
+    
+        c = GMP::Q( "9753108642/2")
+    neg_c = GMP::Q("-9753108642/2")
+    assert_equal(neg_c, -c,     "GMP::Q#-@ should work.")
+    assert_equal(neg_c,  c.neg, "GMP::Q#neg should work.")
+    c.neg!
+    assert_equal(neg_c,  c,     "GMP::Q#neg! should work.")
+    
+        d = GMP::Q(0)
+    neg_d = GMP::Q(0)
+    assert_equal(neg_d, -d,     "GMP::Q#-@ should work.")
+    assert_equal(neg_d,  d.neg, "GMP::Q#neg should work.")
+    d.neg!
+    assert_equal(neg_d,  d,     "GMP::Q#neg! should work.")
+  end
+  
+  def test_abs
+        a = GMP::Q(1,2)
+    abs_a = GMP::Q(1,2)
+    assert_equal(abs_a,  a.abs, "GMP::Q#abs should work.")
+    a.abs!
+    assert_equal(abs_a,  a,     "GMP::Q#abs! should work.")
+    
+        b = GMP::Q(-4,3)
+    abs_b = GMP::Q( 4,3)
+    assert_equal(abs_b,  b.abs, "GMP::Q#abs should work.")
+    b.abs!
+    assert_equal(abs_b,  b,     "GMP::Q#abs! should work.")
+    
+        c = GMP::Q("9753108642/2")
+    abs_c = GMP::Q("9753108642/2")
+    assert_equal(abs_c,  c.abs, "GMP::Q#abs should work.")
+    c.abs!
+    assert_equal(abs_c,  c,     "GMP::Q#abs! should work.")
+    
+        d = GMP::Q(0)
+    abs_d = GMP::Q(0)
+    assert_equal(abs_d,  d.abs, "GMP::Q#abs should work.")
+    d.abs!
+    assert_equal(abs_d,  d,     "GMP::Q#abs! should work.")
+  end
+  
+  def test_inv
+        a = GMP::Q(1,2)
+    inv_a = GMP::Q(2,1)
+    assert_equal(inv_a,  a.inv, "GMP::Q#inv should work.")
+    a.inv!
+    assert_equal(inv_a,  a,     "GMP::Q#inv! should work.")
+    
+        b = GMP::Q(-4,3)
+    inv_b = GMP::Q(-3,4)
+    assert_equal(inv_b,  b.inv, "GMP::Q#inv should work.")
+    b.inv!
+    assert_equal(inv_b,  b,     "GMP::Q#inv! should work.")
+    
+        c = GMP::Q("9753108642/2")
+    inv_c = GMP::Q("2/9753108642")
+    assert_equal(inv_c,  c.inv, "GMP::Q#inv should work.")
+    c.inv!
+    assert_equal(inv_c,  c,     "GMP::Q#inv! should work.")
+    
+    d = GMP::Q(0)
+    assert_raise(ZeroDivisionError) { d.inv }
+    assert_raise(ZeroDivisionError) { d.inv! }
+  end
+  
   def test_to_s
     assert_equal("1/2", GMP::Q(1,2).to_s, "GMP::Q should to_s properly.")
     assert_equal("1/4294967296", GMP::Q(1,2**32).to_s, "GMP::Q should to_s properly.")

data/test/tc_q_basic.rb

@@ -32,8 +32,8 @@ class TC_Q_Basic < Test::Unit::TestCase
     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(@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
+    #assert_equal(@d * @a, GMP::Q(429496729600, 11),"Bignum should multiply GMP::Q correctly")  # SEGFAULT
   end
 end

data/test/tc_z.rb

@@ -51,21 +51,51 @@ class TC_Z < Test::Unit::TestCase
     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.")
+  
+  def test_divisible_ui
+    a = GMP::Z(120)
+    b = GMP::Z(17)
+    a_factors = [1,2,3,4,5,6,8,10,12,15,20,24,30,40,60,120]
+    a_factors.each do |d|
+      assert_true(a.divisible?(d), "GMP::Z#divisible? ui should be false: #{a}.divisible? #{d}")
+    end
+    ((1..120).to_a - a_factors).each do |d|
+      assert_false(a.divisible?(d), "GMP::Z#divisible? ui should be false: #{a}.divisible? #{d}")
+    end
+    (2..16).to_a.each do |d|
+      assert_false(b.divisible?(d), "GMP::Z#divisible? ui should be false: #{a}.divisible? #{d}")
+    end
+  end
+  
+  def test_divisible_bignum
+    a = GMP::Z(2**71 - 3**31)
+    a_factors = [29,    743,        109_582_894_312_963_583,
+                     29*743,     29*109_582_894_312_963_583,
+                                743*109_582_894_312_963_583,
+                             29*743*109_582_894_312_963_583]
+    a_factors.each do |d|
+      assert_true(a.divisible?(d), "GMP::Z#divisible? bignum should be false: #{a}.divisible? #{d}")
+    end
+    a_factors.map { |n| n*2 }.each do |d|
+      assert_false(a.divisible?(d), "GMP::Z#divisible? ui should be false: #{a}.divisible? #{d}")
+    end
+    a_factors.map { |n| n*3 }.each do |d|
+      assert_false(a.divisible?(d), "GMP::Z#divisible? ui should be false: #{a}.divisible? #{d}")
+    end
+  end
+  
+  def test_divisible_z
+    a = GMP::Z(120)
+    b = GMP::Z(17)
+    a_factors = [1,2,3,4,5,6,8,10,12,15,20,24,30,40,60,120].map { |n| GMP::Z(n) }
+    a_factors.each do |d|
+      assert_true(a.divisible?(d), "GMP::Z#divisible? GMP::Z should be true: #{a}.divisible? #{d}")
+    end
+    ((1..120).to_a.map { |n| GMP::Z(n) } - a_factors).each do |d|
+      assert_false(a.divisible?(d), "GMP::Z#divisible? ui should be false: #{a}.divisible? #{d}")
+    end
+    (2..16).to_a.map { |n| GMP::Z(n) }.each do |d|
+      assert_false(b.divisible?(d), "GMP::Z#divisible? ui should be false: #{a}.divisible? #{d}")
+    end
   end
 end

data/test/tc_z_submul.rb

@@ -0,0 +1,94 @@
+require './test_helper'
+
+# Tested: [Z op (Z,Z), Z op (Z,Fixnum), Z op (Z,Bignum),
+#          Z op (Fixnum,Z), Z op (Fixnum,Fixnum), Z op (Fixnum,Bignum)
+#          Z op (Bignum,Z), Z op (Bignum,Bignum), Z op (Bignum,Fixnum)]
+# Things are tested both ways because the implementation is asymetrical
+class TC_Z_Submul < Test::Unit::TestCase
+  def setup
+    @_64bit = 1_000_000_000_000.is_a? Fixnum
+  end
+
+  def test_z
+    five = GMP::Z(5)
+    seven = GMP::Z(7)
+    five.submul!(seven, seven)  # <= 5 - 49
+    assert_equal(-44, five, "GMP::Z should submul GMP::Z correctly")
+    five = GMP::Z(5)
+    twenty = GMP::Z(20)
+    neg2 = GMP::Z(-2)
+    five.submul!(twenty, neg2)  # <= 5 - -40
+    assert_equal(45, five, "GMP::Z should submul GMP::Z correctly")
+    m20 = GMP::Z(2)**20 - 1  # 1_048_575
+    m19 = GMP::Z(2)**19 - 1  #   524_287
+    neg_two = GMP::Z(-2)
+    m20.submul!(m19, neg_two)  # <= 1_048_575 - -1_048_574
+    assert_equal(2_097_149, m20, "GMP::Z should submul GMP::Z correctly")
+    
+    neg_m40 = -GMP::Z(2)**40  # -1_099_511_627_776
+    ten_million  =        10_000_000
+    neg_million  = -GMP::Z(1_000_000)
+    million      =  GMP::Z(1_000_000)
+    thirty_thou  =  GMP::Z(   30_000)
+    thirty       =  GMP::Z(       30)
+    neg_m40.submul!(-neg_million,   neg_million)   # <= -1_099_511_627_776 + 1_000_000_000_000
+    assert_equal(GMP::Z(-99_511_627_776), neg_m40, "GMP::Z should submul GMP::Z correctly")
+    neg_m40.submul!(-ten_million, GMP::Z(9_000))   # <= -   99_511_627_776 +    90_000_000_000
+    assert_equal(GMP::Z(- 9_511_627_776), neg_m40, "GMP::Z should submul GMP::Z correctly")
+    neg_m40.submul!(    -million, GMP::Z(9_000))   # <= -    9_511_627_776 +     9_000_000_000
+    assert_equal(GMP::Z(-   511_627_776), neg_m40, "GMP::Z should submul GMP::Z correctly")
+    neg_m40.submul!(GMP::Z(-17_000), thirty_thou)  # <= -      511_627_776 +       510_000_000
+    assert_equal(GMP::Z(-     1_627_776), neg_m40, "GMP::Z should submul GMP::Z correctly")
+    neg_m40.submul!(GMP::Z(400), GMP::Z(-4000))  # <= -        1_627_776 +         1_600_000
+    assert_equal(GMP::Z(-        27_776), neg_m40, "GMP::Z should submul GMP::Z correctly")
+    neg_m40.submul!(GMP::Z(30), thirty*(-30))    # <= -           27_776 +            27_000
+    assert_equal(GMP::Z(-           776), neg_m40, "GMP::Z should submul GMP::Z correctly")
+  end
+
+  def test_fixnum
+    five = GMP::Z(5)
+    five.submul!(7, 7)  # <= 5 - 49
+    assert_equal(-44, five, "GMP::Z should submul Fixnum correctly")
+    five = GMP::Z(5)
+    five.submul!(-20, 2)  # <= 5 - -40
+    assert_equal(45, five, "GMP::Z should submul Fixnum correctly")
+    m20 = GMP::Z(2)**20 - 1  # 1_048_575
+    m20.submul!(-524_287, 2)  # <= 1_048_575 - -1_048_574
+    assert_equal(2_097_149, m20, "GMP::Z should submul Fixnum correctly")
+    if @_64bit
+      neg_m40 = -GMP::Z(2)**40  # -1_099_511_627_776
+      neg_m40.submul!( 1_000_000_000_000,  1)  # <= -1_099_511_627_776 - 1_000_000_000_000
+      assert_equal(GMP::Z(-2_099_511_627_776), neg_m40, "GMP::Z should submul 64-bit Fixnum correctly")
+    end
+  end
+
+  def test_bignum
+    if ! @_64bit
+      neg_m40 = -GMP::Z(2)**40  # -1_099_511_627_776
+      neg_m40.submul!( -1_000_000_000_000,  1)  # <= -1_099_511_627_776 - -1_000_000_000_000
+      assert_equal(GMP::Z(-99_511_627_776), neg_m40, "GMP::Z should addmul Bignum correctly")
+      neg_m40.submul!(-10,      9_000_000_000)  # <= -   99_511_627_776 -    -90_000_000_000
+      assert_equal(GMP::Z(- 9_511_627_776), neg_m40, "GMP::Z should addmul Bignum correctly")
+      neg_m40.submul!( -3_000_000_000,      3)  # <= -    9_511_627_776 -     -9_000_000_000
+      assert_equal(GMP::Z(-   511_627_776), neg_m40, "GMP::Z should addmul Bignum correctly")
+    else
+      m70 = GMP::Z(2)**70 - 1  # 1_180_591_620_717_411_303_423
+      m70.submul!(11*10_000_000_000, 10_000_000_000)
+      assert_equal(GMP::Z(80_591_620_717_411_303_423), m70, "GMP::Z should addmul 64-bit Bignum correctly")
+      m70.submul!(1_000_000_000, 8*10_000_000_000)
+      assert_equal(GMP::Z(   591_620_717_411_303_423), m70, "GMP::Z should addmul 64-bit Bignum correctly")
+    end
+  end
+
+  def test_raise
+    if ! @_64bit
+      assert_raise(RangeError) { GMP::Z(123).submul!(456, -7) }
+      assert_nothing_raised(RangeError) { GMP::Z(123).submul!(456, -7_000_000_000) }
+    else
+      assert_raise(RangeError) { GMP::Z(123).submul!(456, -7_000_000_000) }
+      assert_nothing_raised(RangeError) { GMP::Z(123).submul!(456, -7_000_000_000_000_000_000) }
+    end
+      assert_nothing_raised(RangeError) { GMP::Z(123).submul!(456, 7) }
+      assert_nothing_raised(RangeError) { GMP::Z(123).submul!(456, GMP::Z(-7)) }
+  end
+end

data/test/tc_z_to_dis.rb

@@ -0,0 +1,69 @@
+require './test_helper'
+
+class TC_to_i_to_d < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z.new(100)
+    @b = GMP::Z.pow(2,32)
+    @c = GMP::Q.new(200,11)
+    @d = GMP::Z.new(-123456789)
+  end
+  
+  def test_to_i
+    assert_equal(@a.to_i, 100, "GMP::Z should to_i correctly.")
+    assert_equal(@a.to_i.class, Fixnum, "GMP::Z.to_i should be a Fixnum.")
+    assert_equal(@b.to_i, 2**32, "GMP::Z (Bignum) should to_i correctly.")
+  end
+  
+  def test_to_d
+    assert_equal(@a.to_d, 100.0, "GMP::Z should to_d correctly.")
+    assert_equal(@a.to_d.class, Float, "GMP::Z.to_d should be a Float.")
+    #assert_equal(@b.to_d, 2**32*1.0, "GMP::Z should to_d correctly.")
+    assert_equal(@b.to_d.class, Float, "GMP::Z.to_d should be a Float.")
+    assert_equal(@c.to_d.class, Float, "GMP::Q.to_d should be a Float.")
+  end
+  
+  def test_to_s
+    assert_equal(                         "100", @a.to_s      , "GMP::Z should to_s correctly.")
+    assert_equal(                  "4294967296", @b.to_s      , "GMP::Z should to_s correctly.")
+    assert_equal("-111010110111100110100010101", @d.to_s(   2), "GMP::Z should to_s correctly.")
+    assert_equal(          "-22121022020212200", @d.to_s(   3), "GMP::Z should to_s correctly.")
+    assert_equal(             "-13112330310111", @d.to_s(   4), "GMP::Z should to_s correctly.")
+    assert_equal(               "-223101104124", @d.to_s(   5), "GMP::Z should to_s correctly.")
+    assert_equal(                "-20130035113", @d.to_s(   6), "GMP::Z should to_s correctly.")
+    assert_equal(                 "-3026236221", @d.to_s(   7), "GMP::Z should to_s correctly.")
+    assert_equal(                  "-726746425", @d.to_s(   8), "GMP::Z should to_s correctly.")
+    assert_equal(                  "-277266780", @d.to_s(   9), "GMP::Z should to_s correctly.")
+    assert_equal(                  "-123456789", @d.to_s(  10), "GMP::Z should to_s correctly.")
+    assert_equal(                   "-63762a05", @d.to_s(  11), "GMP::Z should to_s correctly.")
+    assert_equal(                   "-35418a99", @d.to_s(  12), "GMP::Z should to_s correctly.")
+    assert_equal(                   "-1c767471", @d.to_s(  13), "GMP::Z should to_s correctly.")
+    assert_equal(                   "-12579781", @d.to_s(  14), "GMP::Z should to_s correctly.")
+    assert_equal(                    "-ac89bc9", @d.to_s(  15), "GMP::Z should to_s correctly.")
+    assert_equal(                    "-75bcd15", @d.to_s(  16), "GMP::Z should to_s correctly.")
+    assert_equal(                   "-63762A05", @d.to_s( -11), "GMP::Z should to_s correctly.")
+    assert_equal(                   "-35418A99", @d.to_s( -12), "GMP::Z should to_s correctly.")
+    assert_equal(                   "-1C767471", @d.to_s( -13), "GMP::Z should to_s correctly.")
+    assert_equal(                   "-12579781", @d.to_s( -14), "GMP::Z should to_s correctly.")
+    assert_equal(                    "-AC89BC9", @d.to_s( -15), "GMP::Z should to_s correctly.")
+    assert_equal(                    "-75BCD15", @d.to_s( -16), "GMP::Z should to_s correctly.")
+    assert_equal("-111010110111100110100010101", @d.to_s(:bin), "GMP::Z should to_s correctly.")
+    assert_equal(                  "-726746425", @d.to_s(:oct), "GMP::Z should to_s correctly.")
+    assert_equal(                  "-123456789", @d.to_s(:dec), "GMP::Z should to_s correctly.")
+    assert_equal(                    "-75bcd15", @d.to_s(:hex), "GMP::Z should to_s correctly.")
+    
+    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/unit_tests.rb

@@ -6,27 +6,30 @@ require './tc_constants'
 require './tc_z'
 require './tc_z_basic'
 require './tc_z_addmul'
+require './tc_z_submul'
 require './tc_z_logic'
+require './tc_z_exponentiation'
+require './tc_z_to_dis'
+require './tc_z_shifts_last_bits'
+require './tc_z_jac_leg_rem'
+require './tc_z_gcd_lcm_invert'
 require './tc_q'
 require './tc_cmp'
 require './tc_q_basic'
-require './tc_z_exponentiation'
 require './tc_zerodivisionexceptions'
 require './tc_sgn_neg_abs'
 require './tc_fib_fac_nextprime'
 require './tc_swap'
 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'
 require './tc_division'
-require './tc_z_jac_leg_rem'
-require './tc_z_gcd_lcm_invert'
 require './tc_random'
 require './tc_hashes'
 
+require './gmp_tgcd'
+
 begin
   GMP::MPFR_VERSION
   require './tc_mpfr_constants'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: gmp
 version: !ruby/object:Gem::Version 
-  hash: 13
+  hash: 37
   prerelease: false
   segments: 
   - 0
   - 5
-  - 3
-  version: 0.5.3
+  - 23
+  version: 0.5.23
 platform: ruby
 authors: 
 - Tomasz Wegrzanowski
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-20 00:00:00 -07:00
+date: 2010-10-04 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -46,7 +46,9 @@ files:
 - ext/takeover.h
 - ext/extconf.rb
 - lib/gmp.rb
+- test/gmp_tgcd.rb
 - test/mpfr_tcbrt.rb
+- test/mpfr_tconst_euler.rb
 - test/mpfr_tisnan.rb
 - test/mpfr_trec_sqrt.rb
 - test/mpfr_tsqrt.rb
@@ -77,9 +79,8 @@ files:
 - test/tc_z_jac_leg_rem.rb
 - test/tc_z_logic.rb
 - test/tc_z_shifts_last_bits.rb
-- test/tc_z_to_d_to_i.rb
-- test/test-12.rb
-- test/test-19.rb
+- test/tc_z_submul.rb
+- test/tc_z_to_dis.rb
 - test/test-20.rb
 - test/test-21.rb
 - test/test-22.rb
@@ -91,7 +92,6 @@ files:
 - benchmark/COPYING
 - benchmark/divide
 - benchmark/gcd
-- benchmark/gexpr
 - benchmark/gexpr.c
 - benchmark/multiply
 - benchmark/multiply.gc
@@ -106,7 +106,8 @@ files:
 - README.rdoc
 - manual.pdf
 - manual.tex
-has_rdoc: true
+- FEATURES.html
+has_rdoc: yard
 homepage: http://github.com/srawlins/gmp
 licenses: []
 

data/test/tc_z_to_d_to_i.rb

@@ -1,24 +0,0 @@
-require './test_helper'
-
-class TC_to_i_to_d < Test::Unit::TestCase
-  def setup
-    @a = GMP::Z.new(100)
-    #@b = GMP::Z.pow(2,32)
-    @c = GMP::Q.new(200,11)
-  end
-  
-  def test_to_i
-    assert_equal(@a.to_i, 100, "GMP::Z should to_i correctly.")
-    assert_equal(@a.to_i.class, Fixnum, "GMP::Z.to_i should be a Fixnum.")
-    #assert_equal(@b.to_i, 2**32, "GMP::Z (Bignum) should to_i correctly.")
-    #assert_equal(@b.to_i.class, Bignum, "GMP::Z.to_i should be a Bignum.")
-  end
-  
-  def test_to_d
-    assert_equal(@a.to_d, 100.0, "GMP::Z should to_d correctly.")
-    assert_equal(@a.to_d.class, Float, "GMP::Z.to_d should be a Float.")
-    #assert_equal(@b.to_d, 2**32*1.0, "GMP::Z should to_d correctly.")
-    #assert_equal(@b.to_d.class, Float, "GMP::Z.to_d should be a Float.")
-    assert_equal(@c.to_d.class, Float, "GMP::Q.to_d should be a Float.")
-  end
-end