gmp 0.1.7

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_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/tc_z_shifts_last_bits.rb

@@ -0,0 +1,22 @@
+require 'test_helper'
+
+class TC_shifts_last_bits < Test::Unit::TestCase
+  def setup
+    @a = GMP::Z.new(100)  # 01100100
+    @b =- @a              # 10011100
+  end
+  
+  def test_shifts
+    assert_equal(   3, @a >> 5, "GMP::Z should >> correctly.")  # 00000011
+    assert_equal(-  4, @b >> 5, "GMP::Z should >> correctly.")  # 11111100
+    assert_equal( 400, @a << 2, "GMP::Z should << correctly.")  # 0110010000
+    assert_equal(-400, @b << 2, "GMP::Z should << correctly.")  # 1110010000
+  end
+  
+  def test_last_bits
+    #assert_equal( 5, @a.lastbits_pos(5), "GMP::Z should lastbits_pos correctly.")  #   100
+    #assert_equal(28, @b.lastbits_pos(5), "GMP::Z should lastbits_pos correctly.")  # 11100
+    #assert_equal(-4, @b.lastbits_sgn(5), "GMP::Z should lastbits_sgn correctly.")
+    # a.tshr 5 ???
+  end
+end

data/test/tc_z_to_d_to_i.rb

@@ -0,0 +1,24 @@
+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

data/test/tc_zerodivisionexceptions.rb

@@ -0,0 +1,17 @@
+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

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,135 @@
+#!/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'
+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'
+
+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
+
+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

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification 
+name: gmp
+version: !ruby/object:Gem::Version 
+  version: 0.1.7
+platform: ruby
+authors: 
+- Tomasz Wegrzanowski
+- srawlins
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-01 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: gmp - providing Ruby bindings to the GMP library.
+email: 
+- Tomasz.Wegrzanowski@gmail.com
+- sam.rawlins@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: []
+
+files: 
+- ext/extconf.rb
+- ext/gmp.c
+- ext/gmpf.c
+- ext/gmpf.h
+- ext/gmpq.c
+- ext/gmpq.h
+- ext/gmpz.c
+- ext/gmpz.h
+- ext/ruby_gmp.h
+- ext/takeover.h
+- test/README
+- test/tc_cmp.rb
+- test/tc_fib_fac_nextprime.rb
+- test/tc_floor_ceil_truncate.rb
+- test/tc_logical_roots.rb
+- test/tc_q.rb
+- test/tc_q_basic.rb
+- test/tc_sgn_neg_abs.rb
+- test/tc_swap.rb
+- test/tc_z.rb
+- test/tc_z_basic.rb
+- test/tc_z_exponentiation.rb
+- test/tc_z_logic.rb
+- test/tc_z_shifts_last_bits.rb
+- test/tc_z_to_d_to_i.rb
+- test/tc_zerodivisionexceptions.rb
+- test/test_helper.rb
+- test/unit_tests.rb
+- CHANGELOG
+- INSTALL
+- README.rdoc
+- manual.tex
+has_rdoc: false
+homepage: http://github.com/srawlins/gmp/tree/master
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- ext
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.8.1
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: 
+- GMP compiled and working properly.
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Provides Ruby bindings to the GMP library.
+test_files: []
+