gmp 0.4.7-x86-mingw32 → 0.5.3-x86-mingw32

data/test/tc_division.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require './test_helper'
 
 class TC_division < Test::Unit::TestCase
   def setup
@@ -15,12 +15,23 @@ class TC_division < Test::Unit::TestCase
     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.")
+    begin
     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.")
+    rescue TypeError => e
+      if e.message == "GMP::Q can't be coerced into Float"
+        puts ""
+        puts "Suppressing error that should be fixed with a recent version of Test::Unit"
+        puts "installed."
+      else
+        puts "Accidentally rescued TypeError with message \"#{e.message}\", raising..."
+        raise e
+      end
+    end
   end
   
   def test_z_tdiv
@@ -106,4 +117,4 @@ class TC_division < Test::Unit::TestCase
     assert_raise(TypeError) { @a % GMP::Q(22,3) }
     assert_raise(TypeError) { @a % GMP::F(3.14) }
   end
-end
+end

data/test/tc_f_arithmetics_coersion.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require './test_helper'
 
 class TC_F_arithmetics_coersion < Test::Unit::TestCase
   def setup
@@ -68,4 +68,4 @@ class TC_F_arithmetics_coersion < Test::Unit::TestCase
     assert_in_delta(          0.6962305987,   @a / 4.51, 1e-6)
     assert_in_delta(          1.4363057325, 4.51 /   @a, 1e-6)
   end
-end
+end

data/test/tc_f_precision.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require './test_helper'
 
 class TC_precision < Test::Unit::TestCase
   def setup
@@ -102,7 +102,8 @@ class TC_precision < Test::Unit::TestCase
       GMP::F.default_prec = 100
       assert_equal(128, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
       GMP::F.default_prec = 130
-      assert_equal(160, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
+      adjusted = (130*1.0/GMP::GMP_BITS_PER_LIMB).ceil*GMP::GMP_BITS_PER_LIMB
+      assert_equal(adjusted, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
       GMP::F.default_prec = 1000
       assert_equal(1024, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
       assert_raise(RangeError) { GMP::F.default_prec = -64 }
@@ -110,4 +111,4 @@ class TC_precision < Test::Unit::TestCase
     end
     GMP::F.default_prec =  @initial_default_prec
   end
-end
+end

data/test/tc_fib_fac_nextprime.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require './test_helper'
 
 class TC_fib_fac_nextprime < Test::Unit::TestCase
   def setup
@@ -48,4 +48,4 @@ class TC_fib_fac_nextprime < Test::Unit::TestCase
     assert_equal(@z17, @z13.next_prime, "GMP::Z.nextprime should work.")
     assert_equal(@z19, @z17.nextprime,  "GMP::Z.nextprime should work.")
   end
-end
+end

data/test/tc_floor_ceil_truncate.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require './test_helper'
 
 class TC_floor_ceil_truncate < Test::Unit::TestCase
   def setup
@@ -18,4 +18,4 @@ class TC_floor_ceil_truncate < Test::Unit::TestCase
     assert_equal(@c.ceil, 7, "GMP::Q (integer) should ceil.")
     assert_equal(@c.trunc, 7, "GMP::Q (integer) should truncate.")
   end
-end
+end

data/test/tc_hashes.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 class TC_Hashes < Test::Unit::TestCase
   def setup
   end

data/test/tc_logical_roots.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 class TC_logical_roots < Test::Unit::TestCase
   def setup
     @a = GMP::Z.new(100)
@@ -45,4 +43,4 @@ class TC_logical_roots < Test::Unit::TestCase
     assert_equal(3, @b.root(3), "GMP::Z should root correctly.")
     assert_equal(4, @c.root(3), "GMP::Z should root correctly.")
   end
-end
+end

data/test/tc_mpfr_constants.rb

@@ -0,0 +1,11 @@
+class TC_MPFR_Constants < Test::Unit::TestCase
+  def test_mpfr_constants
+    assert_instance_of(String,   GMP::MPFR_VERSION,  "GMP::MPFR_VERSION should be a String")
+    assert_instance_of(Fixnum,   GMP::MPFR_PREC_MIN, "GMP::MPFR_PREC_MIN should be a Fixnum")
+    assert_instance_of(Fixnum,   GMP::MPFR_PREC_MAX, "GMP::MPFR_PREC_MAX should be a Fixnum")
+    assert_instance_of(GMP::Rnd, GMP::GMP_RNDN,      "GMP::GMP_RNDN should be a GMP::Rnd")
+    assert_instance_of(GMP::Rnd, GMP::GMP_RNDZ,      "GMP::GMP_RNDZ should be a GMP::Rnd")
+    assert_instance_of(GMP::Rnd, GMP::GMP_RNDU,      "GMP::GMP_RNDU should be a GMP::Rnd")
+    assert_instance_of(GMP::Rnd, GMP::GMP_RNDD,      "GMP::GMP_RNDD should be a GMP::Rnd")
+  end
+end

data/test/tc_mpfr_functions.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 class TC_MPFR_Functions < Test::Unit::TestCase
   def setup
     @a = GMP::F(1)
@@ -13,7 +11,17 @@ class TC_MPFR_Functions < Test::Unit::TestCase
   end
   
   def test_function_existence
+    assert_nothing_raised("GMP::F.nan? should be callable.") { @a.nan? }
+    assert_nothing_raised("GMP::F.infinite? should be callable.") { @a.infinite? }
+    assert_nothing_raised("GMP::F.finite? should be callable.") { @a.finite? }
+    assert_nothing_raised("GMP::F.number? should be callable.") { @a.number? }
+    if GMP::MPFR_VERSION >= "3.0.0"
+    assert_nothing_raised("GMP::F.regular? should be callable.") { @a.regular? }
+    end
+
     assert_nothing_raised("GMP::F.sqrt should be callable.") { @a.sqrt }
+    assert_nothing_raised("GMP::F.rec_sqrt should be callable.") { @a.rec_sqrt }
+    assert_nothing_raised("GMP::F.cbrt should be callable.") { @a.cbrt }
     
     assert_nothing_raised("GMP::F.log should be callable.") { @a.log }
     assert_nothing_raised("GMP::F.log2 should be callable.") { @a.log2 }
@@ -50,6 +58,9 @@ class TC_MPFR_Functions < Test::Unit::TestCase
     assert_nothing_raised("GMP::F.gamma should be callable.") { @a.gamma }
     assert_nothing_raised("GMP::F.lngamma should be callable.") { @a.lngamma }
     #assert_nothing_raised("GMP::F.lgamma should be callable.") { @a.lgamma }
+    if GMP::MPFR_VERSION >= "3.0.0"
+    assert_nothing_raised("GMP::F.digamma should be callable.") { @a.digamma }
+    end
     assert_nothing_raised("GMP::F.zeta should be callable.") { @a.zeta }
     assert_nothing_raised("GMP::F.erf should be callable.") { @a.erf }
     assert_nothing_raised("GMP::F.erfc should be callable.") { @a.erfc }
@@ -68,7 +79,8 @@ class TC_MPFR_Functions < Test::Unit::TestCase
   end
   
   def test_function_parameters
-    functions = [:sqrt, :log, :log2, :log10, :exp, :exp2, :exp10,
+    functions = [:sqrt, :rec_sqrt, :cbrt,
+                 :log, :log2, :log10, :exp, :exp2, :exp10,
                  :cos, :sin, :tan, :sec, :csc, :cot, :acos, :asin, :atan,
                  :cosh, :sinh, :tanh, :sech, :csch, :coth,
                  :acosh, :asinh, :atanh,
@@ -76,13 +88,14 @@ class TC_MPFR_Functions < Test::Unit::TestCase
                  :zeta, :erf, :erfc,
                  :j0, :j1, :y0, :y1
                 ]
+    functions += [:digamma] if GMP::MPFR_VERSION >= "3.0.0"
     
     functions.each do |f|
-      assert_nothing_raised("GMP::F.#{f} can be called with 1 argument, the rounding_mode.") { @a.send(f, GMP::GMP_RNDN) }
-      assert_nothing_raised("GMP::F.#{f} can be called with 1 argument, the rounding_mode.") { @a.send(f, GMP::GMP_RNDZ) }
-      assert_nothing_raised("GMP::F.#{f} can be called with 2 args, rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 32) }
-      assert_nothing_raised("GMP::F.#{f} can be called with 2 args, rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 128) }
-      assert_nothing_raised("GMP::F.#{f} can be called with 2 args, rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 200) }
+      assert_nothing_raised("GMP::F.#{f} can be called w/ 1 arg: rounding_mode.") { @a.send(f, GMP::GMP_RNDN) }
+      assert_nothing_raised("GMP::F.#{f} can be called w/ 1 arg: rounding_mode.") { @a.send(f, GMP::GMP_RNDZ) }
+      assert_nothing_raised("GMP::F.#{f} can be called w/ 2 args: rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 32) }
+      assert_nothing_raised("GMP::F.#{f} can be called w/ 2 args: rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 128) }
+      assert_nothing_raised("GMP::F.#{f} can be called w/ 2 args: rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 200) }
     end
   end
-end
+end

data/test/tc_mpfr_random.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 class TC_MPFR_Random < Test::Unit::TestCase
   def setup
   end
@@ -46,4 +44,4 @@ class TC_MPFR_Random < Test::Unit::TestCase
     assert_in_delta(GMP::F("0.23084385480845748"), @d.mpfr_urandomb, 1e-12, "GMP::RandState should be independent correctly.")
     assert_in_delta(GMP::F("0.23084385480845748"), @e.mpfr_urandomb, 1e-12, "GMP::RandState should be independent correctly.")
   end
-end
+end

data/test/tc_mpfr_rounding.rb

@@ -1,7 +1,10 @@
-require 'test_helper'
-
 class TC_MPFR_Rounding < Test::Unit::TestCase
   def setup
+    if GMP::MPFR_VERSION < "3.0.0"
+      @prefix = "GMP"
+    else
+      @prefix = "MPFR"
+    end
   end
 
   def test_rounding_mode
@@ -12,10 +15,10 @@ class TC_MPFR_Rounding < Test::Unit::TestCase
   end
   
   def test_rounding_name
-    assert_equal("GMP_RNDN", GMP::GMP_RNDN.name, "GMP::Rnd.name should be correct.")
-    assert_equal("GMP_RNDZ", GMP::GMP_RNDZ.name, "GMP::Rnd.name should be correct.")
-    assert_equal("GMP_RNDU", GMP::GMP_RNDU.name, "GMP::Rnd.name should be correct.")
-    assert_equal("GMP_RNDD", GMP::GMP_RNDD.name, "GMP::Rnd.name should be correct.")
+    assert_equal(@prefix+"_RNDN", GMP::GMP_RNDN.name, "GMP::Rnd.name should be correct.")
+    assert_equal(@prefix+"_RNDZ", GMP::GMP_RNDZ.name, "GMP::Rnd.name should be correct.")
+    assert_equal(@prefix+"_RNDU", GMP::GMP_RNDU.name, "GMP::Rnd.name should be correct.")
+    assert_equal(@prefix+"_RNDD", GMP::GMP_RNDD.name, "GMP::Rnd.name should be correct.")
   end
   
   def test_rounding_ieee754
@@ -24,4 +27,4 @@ class TC_MPFR_Rounding < Test::Unit::TestCase
     assert_equal("roundTowardPositive", GMP::GMP_RNDU.ieee754, "GMP::Rnd.ieee754 should be correct.")
     assert_equal("roundTowardNegative", GMP::GMP_RNDD.ieee754, "GMP::Rnd.ieee754 should be correct.")
   end
-end
+end

data/test/tc_q.rb

@@ -1,5 +1,3 @@
-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")
@@ -36,4 +34,4 @@ class TC_Q < Test::Unit::TestCase
     assert_equal("0", GMP::Q(0,2000).to_s, "GMP::Q should to_s properly.")
     assert_equal("0", GMP::Q(0,-2000).to_s, "GMP::Q should to_s properly.")
   end
-end
+end

data/test/tc_q_basic.rb

@@ -1,5 +1,3 @@
-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
@@ -14,8 +12,8 @@ class TC_Q_Basic < Test::Unit::TestCase
     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(GMP::Q(47244640356, 11), @a + @d, "GMP::Z should add Bignum correctly")
+    assert_equal(GMP::Q(122,  11),         2 + @a, "Fixnum should add GMP::Q correctly")
     assert_equal(@d + @a, GMP::Q(47244640356, 11), "Bignum should add GMP::Q correctly")
   end
 
@@ -38,4 +36,4 @@ class TC_Q_Basic < Test::Unit::TestCase
     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
+end

data/test/tc_random.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 class TC_Random < Test::Unit::TestCase
   def setup
   end
@@ -70,4 +68,4 @@ class TC_Random < Test::Unit::TestCase
     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
+end

data/test/tc_sgn_neg_abs.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 class TC_sgn_neg_abs < Test::Unit::TestCase
   def setup
     @a=GMP::Z.new(10)
@@ -44,4 +42,4 @@ class TC_sgn_neg_abs < Test::Unit::TestCase
     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
+end

data/test/tc_swap.rb

@@ -1,5 +1,3 @@
-require 'test_helper'
-
 class TC_swap < Test::Unit::TestCase
   def setup
     @a=GMP::Z.new(100)
@@ -16,4 +14,4 @@ class TC_swap < Test::Unit::TestCase
     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
+end

data/test/tc_z.rb

@@ -1,4 +1,4 @@
-require 'test_helper'
+require './test_helper'
 
 class TC_Z < Test::Unit::TestCase
   def test_init_null
@@ -19,7 +19,7 @@ class TC_Z < Test::Unit::TestCase
   end
 
   def test_init_bignum
-    assert_equal(GMP::Z.new(2**32), 2**32, "GMP::Z.new(x : Bignum) should initialize to x")
+    assert_equal(2**32, GMP::Z.new(2**32), "GMP::Z.new(x : Bignum) should initialize to x")
   end
 
   def test_cmp_z
@@ -68,4 +68,4 @@ class TC_Z < Test::Unit::TestCase
     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
+end

data/test/tc_z_addmul.rb

@@ -0,0 +1,92 @@
+# 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_Addmul < 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.addmul!(seven, seven)  # <= 5 + 49
+    assert_equal(54, five, "GMP::Z should addmul GMP::Z correctly")
+    five = GMP::Z(5)
+    twenty = GMP::Z(20)
+    neg2 = GMP::Z(-2)
+    five.addmul!(twenty, neg2)  # <= 5 + -40
+    assert_equal(-35, five, "GMP::Z should addmul 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.addmul!(m19, neg_two)  # <= 1_048_575 + -1_048_574
+    assert_equal(1, m20, "GMP::Z should addmul 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.addmul!(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 addmul GMP::Z correctly")
+    neg_m40.addmul!(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 addmul GMP::Z correctly")
+    neg_m40.addmul!(    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 addmul GMP::Z correctly")
+    neg_m40.addmul!(GMP::Z(17_000), thirty_thou)  # <= -      511_627_776 +       510_000_000
+    assert_equal(GMP::Z(-     1_627_776), neg_m40, "GMP::Z should addmul GMP::Z correctly")
+    neg_m40.addmul!(GMP::Z(-400), GMP::Z(-4000))  # <= -        1_627_776 +         1_600_000
+    assert_equal(GMP::Z(-        27_776), neg_m40, "GMP::Z should addmul GMP::Z correctly")
+    neg_m40.addmul!(GMP::Z(-30), thirty*(-30))    # <= -           27_776 +            27_000
+    assert_equal(GMP::Z(-           776), neg_m40, "GMP::Z should addmul GMP::Z correctly")
+  end
+
+  def test_fixnum
+    five = GMP::Z(5)
+    five.addmul!(7, 7)  # <= 5 + 49
+    assert_equal(54, five, "GMP::Z should addmul Fixnum correctly")
+    five = GMP::Z(5)
+    five.addmul!(-20, 2)  # <= 5 + -40
+    assert_equal(-35, five, "GMP::Z should addmul Fixnum correctly")
+    m20 = GMP::Z(2)**20 - 1  # 1_048_575
+    m20.addmul!(-524_287, 2)  # <= 1_048_575 + -1_048_574
+    assert_equal(1, m20, "GMP::Z should addmul Fixnum correctly")
+    if @_64bit
+      neg_m40 = -GMP::Z(2)**40  # -1_099_511_627_776
+      neg_m40.addmul!( 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 64-bit Fixnum correctly")
+    end
+  end
+
+  def test_bignum
+    if ! @_64bit
+      neg_m40 = -GMP::Z(2)**40  # -1_099_511_627_776
+      neg_m40.addmul!( 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.addmul!(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.addmul!( 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.addmul!(-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.addmul!(-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).addmul!(456, -7) }
+      assert_nothing_raised(RangeError) { GMP::Z(123).addmul!(456, -7_000_000_000) }
+    else
+      assert_raise(RangeError) { GMP::Z(123).addmul!(456, -7_000_000_000) }
+      assert_nothing_raised(RangeError) { GMP::Z(123).addmul!(456, -7_000_000_000_000_000_000) }
+    end
+      assert_nothing_raised(RangeError) { GMP::Z(123).addmul!(456, 7) }
+      assert_nothing_raised(RangeError) { GMP::Z(123).addmul!(456, GMP::Z(-7)) }
+  end
+end

data/test/tc_z_basic.rb

@@ -1,5 +1,3 @@
-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
@@ -10,11 +8,11 @@ class TC_Z_Basic < Test::Unit::TestCase
   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")
+    assert_equal(100   + 200,   @a + @b, "GMP::Z should add correctly")
+    assert_equal(100   + 2,     @a + 2,  "GMP::Z should add correctly")
+    assert_equal(100   + 2**32, @a + @c, "GMP::Z should add correctly")
+    assert_equal(  2   + 100,   2 + @a,  "GMP::Z should add correctly")
+    assert_equal(2**32 + 100,   @c + @a, "GMP::Z should add correctly")
   end
 
   def test_sub
@@ -32,4 +30,4 @@ class TC_Z_Basic < Test::Unit::TestCase
     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
+end