gmp 0.2.2 → 0.4.0

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

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'gmp'
+
+a=GMP::Q.new(200,11)
+b=-a
+c=a.floor
+d=a.ceil
+e=a.trunc
+f=b.floor
+g=b.ceil
+h=b.trunc
+
+[c,d,e,f,g,h].each { |var| p var }

data/test/test-19.rb

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+require 'gmp'
+
+a=GMP::Z.new(5)
+b=GMP::Z.new(7)
+c=GMP::Q.new(3,11)
+d=GMP::F.new(3.14)
+e=2**32
+
+f=[a/b,a/3,3/a,a/c,c/a,a/d,d/a,a/e,e/a]
+
+f.each {|var| p var}

data/test/test-20.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+
+require 'gmp'
+
+a=GMP::F.new -1
+b=GMP::F.new 0
+c=GMP::F.new 0.1
+d=GMP::F.new 1
+e=GMP::F.new 2
+f=GMP::F.new 4
+g=GMP::F.new 10
+
+print "exp:\n"
+[a,b,c,d,e,f,g].map{|x| p x.exp}
+
+print "log:\n"
+[c,d,e,f,g].map{|x| p x.log}
+
+print "log2:\n"
+[c,d,e,f,g].map{|x| p x.log2}
+
+print "log10:\n"
+[c,d,e,f,g].map{|x| p x.log10}
+
+print "log1p:\n"
+[c,d,e,f,g].map{|x| p x.log1p}
+
+print "expm1:\n"
+[a,b,c,d,e,f,g].map{|x| p x.expm1}

data/test/test-21.rb

@@ -0,0 +1,37 @@
+#!/usr/bin/env ruby
+
+require 'gmp'
+
+pi = GMP::F.new(1).asin * 2
+
+a = GMP::F.new 0
+b = pi / 4
+c = pi / 2
+d = -pi / 2
+
+print "cos:\n"
+[a,b,c,d].map{|x| p x.cos}
+
+print "sin:\n"
+[a,b,c,d].map{|x| p x.sin}
+
+print "tan:\n"
+[a,b,c,d].map{|x| p x.tan}
+
+print "cosh:\n"
+[a,b,c,d].map{|x| p x.cosh}
+
+print "sinh:\n"
+[a,b,c,d].map{|x| p x.sinh}
+
+print "tanh:\n"
+[a,b,c,d].map{|x| p x.tanh}
+
+
+print "inverses:\n"
+[a,b,c,d].map{|x| p [x,x.cos.acos] }
+[a,b,c,d].map{|x| p [x,x.sin.asin] }
+[a,b,c,d].map{|x| p [x,x.tan.atan] }
+[a,b,c,d].map{|x| p [x,x.cosh.acosh] }
+[a,b,c,d].map{|x| p [x,x.sinh.asinh] }
+[a,b,c,d].map{|x| p [x,x.tanh.atanh] }

data/test/test-22.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'gmp'
+
+a = GMP::F.new 0
+b = GMP::F.new 1
+c = b / a
+d = -c
+e = a * c
+
+[a,b,c,d,e].map{|x| p [x, x.finite?, x.infinite?] }
+[a,b,c,d,e].map{|x| p [x, x.number?, x.nan?] }

data/test/test-23.rb

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+require 'gmp'
+
+a = GMP::F.new 256
+b = GMP::F.new 10
+c = GMP::F.new 0.5
+
+[a,b].map{|x| p x.sqrt }
+[a,b].map{|x| p x ** c }
+

data/test/test_helper.rb

@@ -1,2 +1,8 @@
 require 'test/unit'
+require 'rbconfig'
+
+ENV['PATH'] = [File.expand_path(
+  File.join(File.dirname(__FILE__), "..", "ext")
+), ENV['PATH']].compact.join(';') if RbConfig::CONFIG['host_os'] =~ /(mswin|mingw|mingw32)/i
+
 require File.dirname(__FILE__) + '/../ext/gmp'

data/test/unit_tests.rb

@@ -18,107 +18,22 @@ 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'
 
 class TC_default_prec < Test::Unit::TestCase
   def test_default_prec
     assert_equal( 64, GMP::F.default_prec, "GMP::F.default_prec should be 64.")
     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.")
+    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 }
+    assert_raise(TypeError) { GMP::F.default_prec = "Cow" }
     GMP::F.default_prec =  64
   end
-end
-
-class TC_division < Test::Unit::TestCase
-  def setup
-    @a = GMP::Z.new(5)
-    @b = GMP::Z.new(7)
-    @c = GMP::Z.new(25)
-    @d = GMP::Q.new(3,11)
-    @e = GMP::F.new(3.14)
-    @f = 2**32
-  end
-  
-  def test_z_div
-    assert_equal(GMP::Q, (@a / @b   ).class, "GMP::Z / GMP::Z should be GMP::Q.")
-    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.")
-    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.")
-  end
-  
-  def test_z_tdiv
-    assert_equal(GMP::Z, @a.tdiv(@b).class,    "GMP::Z.tdiv GMP::Z should be GMP::Z.")
-    assert_equal(GMP::Z, @a.tdiv(3).class,     "GMP::Z.tdiv Fixnum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.tdiv(2**32).class, "GMP::Z.tdiv Bignum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.tdiv(@c).class,    "GMP::Z.tdiv GMP::Z should be GMP::Z.")
-    assert_equal(0, @a.tdiv(@b), "GMP::Z.tdiv should work.")
-    assert_equal(1, @b.tdiv(@a), "GMP::Z.tdiv should work.")
-    assert_equal(1, @a.tdiv( 3), "GMP::Z.tdiv should work.")
-    assert_equal(0, @a.tdiv(@c), "GMP::Z.tdiv should work.")
-    assert_equal(5, @c.tdiv(@a), "GMP::Z.tdiv should work.")
-  end
-  
-  def test_z_fdiv
-    assert_equal(GMP::Z, @a.fdiv(@b).class,    "GMP::Z.fdiv GMP::Z should be GMP::Z.")
-    assert_equal(GMP::Z, @a.fdiv(3).class,     "GMP::Z.fdiv Fixnum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.fdiv(2**32).class, "GMP::Z.fdiv Bignum should be GMP::Z.")
-    assert_equal(0, @a.fdiv(@b), "GMP::Z.fdiv should work.")
-    assert_equal(1, @b.fdiv(@a), "GMP::Z.fdiv should work.")
-    assert_equal(1, @a.fdiv( 3), "GMP::Z.fdiv should work.")
-    assert_equal(0, @a.fdiv(@c), "GMP::Z.fdiv should work.")
-    assert_equal(5, @c.fdiv(@a), "GMP::Z.fdiv should work.")
-  end
-  
-  def test_z_cdiv
-    assert_equal(GMP::Z, @a.cdiv(@b).class,    "GMP::Z.cdiv GMP::Z should be GMP::Z.")
-    assert_equal(GMP::Z, @a.cdiv(3).class,     "GMP::Z.cdiv Fixnum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.cdiv(2**32).class, "GMP::Z.cdiv Bignum should be GMP::Z.")
-    assert_equal(1, @a.cdiv(@b), "GMP::Z.cdiv should work.")
-    assert_equal(2, @b.cdiv(@a), "GMP::Z.cdiv should work.")
-    assert_equal(2, @a.cdiv( 3), "GMP::Z.cdiv should work.")
-    assert_equal(1, @a.cdiv(@c), "GMP::Z.cdiv should work.")
-    assert_equal(5, @c.cdiv(@a), "GMP::Z.cdiv should work.")
-  end
-  
-  def test_z_tmod
-    assert_equal(GMP::Z, @a.tmod(@b).class,    "GMP::Z.tmod GMP::Z should be GMP::Z.")
-    assert_equal(GMP::Z, @a.tmod(3).class,     "GMP::Z.tmod Fixnum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.tmod(2**32).class, "GMP::Z.tmod Bignum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.tmod(@c).class,    "GMP::Z.tmod GMP::Z should be GMP::Z.")
-    assert_equal(5, @a.tmod(@b), "GMP::Z.tmod should work.")
-    assert_equal(2, @b.tmod(@a), "GMP::Z.tmod should work.")
-    assert_equal(2, @a.tmod( 3), "GMP::Z.tmod should work.")
-    assert_equal(5, @a.tmod(@c), "GMP::Z.tmod should work.")
-    assert_equal(0, @c.tmod(@a), "GMP::Z.tmod should work.")
-  end
-  
-  def test_z_fmod
-    assert_equal(GMP::Z, @a.fmod(@b).class,    "GMP::Z.fmod GMP::Z should be GMP::Z.")
-    assert_equal(GMP::Z, @a.fmod(3).class,     "GMP::Z.fmod Fixnum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.fmod(2**32).class, "GMP::Z.fmod Bignum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.fmod(@c).class,    "GMP::Z.fmod GMP::Z should be GMP::Z.")
-    assert_equal(5, @a.fmod(@b), "GMP::Z.fmod should work.")
-    assert_equal(2, @b.fmod(@a), "GMP::Z.fmod should work.")
-    assert_equal(2, @a.fmod( 3), "GMP::Z.fmod should work.")
-    assert_equal(5, @a.fmod(@c), "GMP::Z.fmod should work.")
-    assert_equal(0, @c.fmod(@a), "GMP::Z.fmod should work.")
-  end
-  
-  def test_z_cmod
-    assert_equal(GMP::Z, @a.cmod(@b).class,    "GMP::Z.cmod GMP::Z should be GMP::Z.")
-    assert_equal(GMP::Z, @a.cmod(3).class,     "GMP::Z.cmod Fixnum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.cmod(2**32).class, "GMP::Z.cmod Bignum should be GMP::Z.")
-    assert_equal(GMP::Z, @a.cmod(@c).class,    "GMP::Z.cmod GMP::Z should be GMP::Z.")
-    assert_equal( -2, @a.cmod(@b), "GMP::Z.cmod should work.")
-    assert_equal( -3, @b.cmod(@a), "GMP::Z.cmod should work.")
-    assert_equal( -1, @a.cmod( 3), "GMP::Z.cmod should work.")
-    assert_equal(-20, @a.cmod(@c), "GMP::Z.cmod should work.")
-    assert_equal(  0, @c.cmod(@a), "GMP::Z.cmod should work.")
-  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gmp
 version: !ruby/object:Gem::Version 
-  version: 0.2.2
+  version: 0.4.0
 platform: ruby
 authors: 
 - Tomasz Wegrzanowski
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-12-22 00:00:00 -07:00
+date: 2010-01-03 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -25,43 +25,64 @@ extensions:
 extra_rdoc_files: []
 
 files: 
-- ext/extconf.rb
 - ext/gmp.c
+- ext/gmpbench_timing.c
 - ext/gmpf.c
-- ext/gmpf.h
 - ext/gmpq.c
-- ext/gmpq.h
+- ext/gmprandstate.c
 - ext/gmpz.c
+- ext/gmpf.h
+- ext/gmpq.h
 - ext/gmpz.h
 - ext/ruby_gmp.h
 - ext/takeover.h
-- test/README
+- ext/extconf.rb
 - test/tc_cmp.rb
-- test/tc_f_precision.rb
-- test/tc_f_arithmetics_coersion.rb
+- test/tc_division.rb
 - test/tc_fib_fac_nextprime.rb
 - test/tc_floor_ceil_truncate.rb
+- test/tc_f_arithmetics_coersion.rb
+- test/tc_f_precision.rb
 - test/tc_logical_roots.rb
 - test/tc_q.rb
 - test/tc_q_basic.rb
+- test/tc_random.rb
 - test/tc_sgn_neg_abs.rb
 - test/tc_swap.rb
 - test/tc_z.rb
+- test/tc_zerodivisionexceptions.rb
 - test/tc_z_basic.rb
 - test/tc_z_exponentiation.rb
+- test/tc_z_gcd_lcm_invert.rb
 - 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/tc_zerodivisionexceptions.rb
+- test/test-12.rb
+- test/test-19.rb
+- test/test-20.rb
+- test/test-21.rb
+- test/test-22.rb
+- test/test-23.rb
 - test/test_helper.rb
 - test/unit_tests.rb
+- test/README
+- benchmark/COPYING
+- benchmark/divide
+- benchmark/gcd
+- benchmark/gexpr
+- benchmark/gexpr.c
+- benchmark/multiply
+- benchmark/README
+- benchmark/rsa
+- benchmark/runbench
+- benchmark/version
 - CHANGELOG
 - INSTALL
 - README.rdoc
 - manual.pdf
 - manual.tex
-has_rdoc: false
+has_rdoc: true
 homepage: http://github.com/srawlins/gmp
 licenses: []