srawlins-gmp 0.1.1

data/ext/takeover.h

@@ -0,0 +1,36 @@
+#define DEFUN_TAKEOVER_LOGIC(fname, mpz_fname, old_fname) \
+static VALUE takeover_fixnum_##fname(int argc, VALUE *argv, VALUE self) \
+{ \
+  MP_INT *res_val, *arg_val; \
+  VALUE res; \
+\
+  if (argc != 1 || !GMPZ_P(argv[0])) { \
+    return rb_funcall2 (self, rb_intern (old_fname), argc, argv); \
+  } else { \
+    mpz_make_struct(res, res_val); \
+    mpz_get_struct(argv[0], arg_val); \
+    mpz_init_set_si (res_val, FIX2INT(self)); \
+    mpz_fname (res_val, res_val, arg_val); \
+    return res; \
+  } \
+} \
+\
+static VALUE takeover_bignum_##fname(int argc, VALUE *argv, VALUE self) \
+{\
+  MP_INT *res_val, *arg_val; \
+  VALUE res; \
+\
+  if (argc != 1 || !GMPZ_P(argv[0])) { \
+    return rb_funcall2 (self, rb_intern (old_fname), argc, argv); \
+  } else { \
+    mpz_get_struct(argv[0], arg_val); \
+    mpz_make_struct_init(res, res_val); \
+    mpz_set_bignum (res_val, self); \
+    mpz_fname (res_val, res_val, arg_val); \
+    return res; \
+  } \
+}
+
+DEFUN_TAKEOVER_LOGIC(and, mpz_and, "old_and")
+DEFUN_TAKEOVER_LOGIC(or, mpz_ior, "old_or")
+DEFUN_TAKEOVER_LOGIC(xor, mpz_xor, "old_xor")

data/test/README

@@ -0,0 +1,41 @@
+TODO: Port everything to Test::Unit framework
+Test files 1-6 ported.
+
+Current version passes:
+  1-23
+Current version fails on these tests because:
+  none
+Tests:
+   1*   initializations and to_s
+   2*   basic integer arithmetics and coertion to Z
+   3*   integer logical operators
+   4*   comparisions between Z, Q, FixNum and BigNum
+   5*   basic rational arithmetics and coertion 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 coercion 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
+TODO:
+  jacobi, legendre, remove
+  gcd, lcm
+  cmpabs
+  integer and integer->rational division, modulo
+  more number theoretic functions
+  random numbers
+  range error exceptions
+  others ?
+  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_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")
+    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")
+  end
+end

data/test/tc_z.rb

@@ -0,0 +1,59 @@
+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(GMP::Z.new(1).to_s, "1", "Z(1).to_s should equal '1'")
+    assert_equal(GMP::Z.new(-1).to_s, "-1", "Z(1).to_s should equal '-1'")
+  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(100), @a.powmod(@b,@c), "(a : GMP::Z).powmod((b : GMP::Z), (c : GMP::Z)) should work correctly")
+  end
+end

data/test/tc_z_logic.rb

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+class TC_Z_Logic < Test::Unit::TestCase
+  def setup
+    @a=GMP::Z.new(0xffff00000000ffff)
+    @b=GMP::Z.new(0xffff0000ffff0000)
+    @c=0xff00ff00ff00ff00
+    @d=0x1248 
+  end
+
+  def test_and
+    assert_equal(@a & @b, 0xffff00000000ffff & 0xffff0000ffff0000, "GMP::Z should AND correctly")
+    assert_equal(@a & @d, 0xffff00000000ffff & 0x1248,             "GMP::Z should AND correctly")
+    assert_equal(@a & @c, 0xffff00000000ffff & 0xff00ff00ff00ff00, "GMP::Z should AND correctly")
+    assert_equal(@d & @a, 0x1248             & 0xffff00000000ffff, "GMP::Z should AND correctly")
+    assert_equal(@c & @a, 0xff00ff00ff00ff00 & 0xffff00000000ffff, "GMP::Z should AND correctly")
+  end
+
+  def test_or
+    assert_equal(@a | @b, 0xffff00000000ffff | 0xffff0000ffff0000, "GMP::Z should OR correctly")
+    assert_equal(@a | @d, 0xffff00000000ffff | 0x1248,             "GMP::Z should OR correctly")
+    assert_equal(@a | @c, 0xffff00000000ffff | 0xff00ff00ff00ff00, "GMP::Z should OR correctly")
+    assert_equal(@d | @a, 0x1248             | 0xffff00000000ffff, "GMP::Z should OR correctly")
+    assert_equal(@c | @a, 0xff00ff00ff00ff00 | 0xffff00000000ffff, "GMP::Z should OR correctly")
+  end
+
+  def test_xor
+    assert_equal(@a ^ @b, 0xffff00000000ffff ^ 0xffff0000ffff0000, "GMP::Z should XOR correctly")
+    assert_equal(@a ^ @d, 0xffff00000000ffff ^ 0x1248,             "GMP::Z should XOR correctly")
+    assert_equal(@a ^ @c, 0xffff00000000ffff ^ 0xff00ff00ff00ff00, "GMP::Z should XOR correctly")
+    assert_equal(@d ^ @a, 0x1248             ^ 0xffff00000000ffff, "GMP::Z should XOR correctly")
+    assert_equal(@c ^ @a, 0xff00ff00ff00ff00 ^ 0xffff00000000ffff, "GMP::Z should XOR correctly")
+  end
+
+  def test_com
+    assert_equal(GMP::Z().com, -1, "GMP::Z.com should complement")
+    assert_equal(GMP::Z(1).com, -2, "GMP::Z.com should complement")
+    assert_equal(GMP::Z(-1).com, 0, "GMP::Z.com should complement")
+    assert_equal(@a.com, -0xffff00000000ffff-1, "GMP::Z.com should complement")
+  end
+
+  def test_logic
+    a=GMP::Z.new(0x1234)
+    b=GMP::Z.new(a)
+    b[0]=true
+
+    assert_equal(a,     0x1234, "GMP::Z.new() should create a new copy, not alias")
+    assert_equal(b,     0x1235, "GMP::Z#[]= should modify bits")
+    assert_equal(a[2],    true, "GMP::Z#[] should access bits")
+    assert_equal(a.scan0(0), 0, "GMP::Z#scan0 should scan for 0s")
+    assert_equal(a.scan1(0), 2, "GMP::Z#scan1 should scan for 1s")
+
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'test/unit'
+require File.dirname(__FILE__) + '/../ext/gmp'

data/test/unit_tests.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/env ruby
+
+require 'test_helper'
+require 'tc_z'
+require 'tc_z_basic'
+require 'tc_z_logic'
+require 'tc_q'
+require 'tc_cmp'
+require 'tc_q_basic'
+require 'tc_z_exponentiation'
+
+
+class TC_ZeroDivisionExceptions < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z.new(10)
+    @b = GMP::Z.new()
+    @c = GMP::Q.new(1)
+    @d = GMP::Q.new()
+  end
+  
+  def test_division_by_zero
+    assert_raise(ZeroDivisionError) { @a.tdiv(0) }
+    assert_raise(ZeroDivisionError) { @a.tdiv(@b) }
+    assert_raise(ZeroDivisionError) { @d.inv }
+    assert_raise(ZeroDivisionError) { @d.inv! }
+    assert_raise(ZeroDivisionError) { @c/0 }
+    assert_raise(ZeroDivisionError) { @c/@d }
+  end
+end
+
+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