gmp 0.4.3-x86-mingw32 → 0.4.7-x86-mingw32

data/test/mpfr_tsqrt.rb

@@ -19,24 +19,52 @@ class MPFR_TSQRT < Test::Unit::TestCase
     assert_equal(integer_component(q), qs)
   end
   
+  def special
+    x = GMP::F(0b1010000010100011011001010101010010001100001101011101110001011001 / 2, 64)  # Ruby 0b does not support e,
+    y = x.sqrt(GMP::GMP_RNDN, 32)                                                           # ie 0b11e-2 = 0.75 doesnt work
+    #assert_equal(2405743844, y, "Error for n^2+n+1/2 with n=2405743843")  # Pending
+    
+    x = GMP::F(0b10100000101000110110010101010100100011000011010111011100010110001 / 4, 65)
+    y = x.sqrt(GMP::GMP_RNDN, 32)
+    #assert_equal(2405743844, y, "Error for n^2+n+1/4 with n=2405743843")  # Pending
+    
+    x = GMP::F(0b101000001010001101100101010101001000110000110101110111000101100011 / 8, 66)
+    y = x.sqrt(GMP::GMP_RNDN, 32)
+    #assert_equal(2405743844, y, "Error for n^2+n+1/4+1/8 with n=2405743843")  # Pending
+    
+    x = GMP::F(0b101000001010001101100101010101001000110000110101110111000101100001 / 8, 66)
+    y = x.sqrt(GMP::GMP_RNDN, 32)
+    assert_equal(2405743843, y, "Error for n^2+n+1/8 with n=2405743843")
+    
+    #####
+    ##### Inexact flag test. Not implemented.
+    
+    #####
+    ##### Test uses mpfr_nexttoinf. Not implemented.
+    
+    # Not an accurate test at all. Reassigning z generates a new mpfr object.
+    x = GMP::F(1)
+    z = GMP::F(-1)
+    z = x.sqrt(GMP::GMP_RNDN)
+    
+    # z = GMP::F(0.1011010100000100100100100110011001011100100100000011000111011001011101101101110000110100001000100001100001011000E1, 160)
+    # x = z.sqrt
+    # z = x.sqrt
+    # x.prec = 53
+  end
+  
   def property1(p, rounding)
-    current_rounding_mode = GMP::F.default_rounding_mode
-    GMP::F.default_rounding_mode = rounding
     x = @rand_state.mpfr_urandomb(p)
     y = @rand_state.mpfr_urandomb(p)
     z = x**2 + y**2
-    z = x / z.sqrt
+    z = x / z.sqrt(rounding)
     assert_between(-1, 1, z, "-1 <= x/sqrt(x^2+y^2) <= 1 should hold.")
-    GMP::F.default_rounding_mode = GMP.const_get(current_rounding_mode)
   end
   
   def property2(p, rounding)
-    current_rounding_mode = GMP::F.default_rounding_mode
-    GMP::F.default_rounding_mode = rounding
     x = @rand_state.mpfr_urandomb(p)
-    y = (x ** 2).sqrt
+    y = (x ** 2).sqrt(rounding)
     assert_true(x == y, "sqrt(x^2) = x should hold.")
-    GMP::F.default_rounding_mode = GMP.const_get(current_rounding_mode)
   end
   
   def test_prec
@@ -49,5 +77,6 @@ class MPFR_TSQRT < Test::Unit::TestCase
     check_diverse("635030154261163106768013773815762607450069292760790610550915652722277604820131530404842415587328",
                   160,
                   "796887792767063979679855997149887366668464780637")
+    special
   end
 end

data/test/tc_hashes.rb

@@ -0,0 +1,30 @@
+require 'test_helper'
+
+class TC_Hashes < Test::Unit::TestCase
+  def setup
+  end
+  
+  def test_z_hashes
+    h = {}
+    h[GMP::Z(131)] = [GMP::Z(41), GMP::Z(43), GMP::Z(47)]
+    assert(h[GMP::Z(131)] != nil, "Newly created GMP::Zs should hash equally if they are equal.")
+    assert(h[GMP::Z(59)].nil?,    "Newly created GMP::Zs should hash differently if they are different.")
+    10.times do
+      assert(GMP::Z(73).hash == GMP::Z(73).hash)
+    end
+    
+    100.times do |i|
+      assert(GMP::Z(101).hash != GMP::Z(i).hash)
+    end
+    
+    # GMP::Z(5) and "5" might (I think, 'do') hash the same, but should not be equal
+    assert(! GMP::Z(101).eql?("101"))
+    
+    h["127"] = "String"
+    h[GMP::Z(127)] = "GMP::Z"
+    assert(h["127"] != "GMP::Z")
+    assert(h[GMP::Z(127)] != "String")
+    assert(h[GMP::Z(127)] == "GMP::Z")
+    assert(h["127"] == "String")
+  end
+end

data/test/tc_mpfr_functions.rb

@@ -19,7 +19,8 @@ class TC_MPFR_Functions < Test::Unit::TestCase
     assert_nothing_raised("GMP::F.log2 should be callable.") { @a.log2 }
     assert_nothing_raised("GMP::F.log10 should be callable.") { @a.log10 }
     assert_nothing_raised("GMP::F.exp should be callable.") { @a.exp }
-    
+    assert_nothing_raised("GMP::F.exp2 should be callable.") { @a.exp2 }
+    assert_nothing_raised("GMP::F.exp10 should be callable.") { @a.exp10 }
     assert_nothing_raised("GMP::F.cos should be callable.") { @a.cos }
     assert_nothing_raised("GMP::F.sin should be callable.") { @a.sin }
     assert_nothing_raised("GMP::F.tan should be callable.") { @a.tan }
@@ -34,12 +35,54 @@ class TC_MPFR_Functions < Test::Unit::TestCase
     assert_nothing_raised("GMP::F.cosh should be callable.") { @a.cosh }
     assert_nothing_raised("GMP::F.sinh should be callable.") { @a.sinh }
     assert_nothing_raised("GMP::F.tanh should be callable.") { @a.tanh }
-    
+
+    assert_nothing_raised("GMP::F.sech should be callable.") { @a.sech }
+    assert_nothing_raised("GMP::F.csch should be callable.") { @a.csch }
+    assert_nothing_raised("GMP::F.coth should be callable.") { @a.coth }
     assert_nothing_raised("GMP::F.acosh should be callable.") { @a.acosh }
     assert_nothing_raised("GMP::F.asinh should be callable.") { @a.asinh }
     assert_nothing_raised("GMP::F.atanh should be callable.") { @a.atanh }
     
     assert_nothing_raised("GMP::F.log1p should be callable.") { @a.log1p }
     assert_nothing_raised("GMP::F.expm1 should be callable.") { @a.expm1 }
+    assert_nothing_raised("GMP::F.eint should be callable.") { @a.eint }
+    assert_nothing_raised("GMP::F.li2 should be callable.") { @a.li2 }
+    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 }
+    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 }
+    assert_nothing_raised("GMP::F.j0 should be callable.") { @a.j0 }
+    assert_nothing_raised("GMP::F.j1 should be callable.") { @a.j1 }
+    assert_nothing_raised("GMP::F.jn should be callable.") { @a.jn(-1) }
+    assert_nothing_raised("GMP::F.jn should be callable.") { @a.jn(0) }
+    assert_nothing_raised("GMP::F.jn should be callable.") { @a.jn(1) }
+    assert_nothing_raised("GMP::F.jn should be callable.") { @a.jn(2) }
+    assert_nothing_raised("GMP::F.y0 should be callable.") { @a.y0 }
+    assert_nothing_raised("GMP::F.y1 should be callable.") { @a.y1 }
+    assert_nothing_raised("GMP::F.yn should be callable.") { @a.yn(-1) }
+    assert_nothing_raised("GMP::F.yn should be callable.") { @a.yn(0) }
+    assert_nothing_raised("GMP::F.yn should be callable.") { @a.yn(1) }
+    assert_nothing_raised("GMP::F.yn should be callable.") { @a.yn(2) }
+  end
+  
+  def test_function_parameters
+    functions = [:sqrt, :log, :log2, :log10, :exp, :exp2, :exp10,
+                 :cos, :sin, :tan, :sec, :csc, :cot, :acos, :asin, :atan,
+                 :cosh, :sinh, :tanh, :sech, :csch, :coth,
+                 :acosh, :asinh, :atanh,
+                 :log1p, :expm1, :eint, :li2, :gamma, :lngamma,
+                 :zeta, :erf, :erfc,
+                 :j0, :j1, :y0, :y1
+                ]
+    
+    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) }
+    end
   end
 end

data/test/tc_mpfr_rounding.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class TC_MPFR_Rounding < Test::Unit::TestCase
+  def setup
+  end
+
+  def test_rounding_mode
+    assert_equal(0, GMP::GMP_RNDN.mode, "GMP::Rnd.mode should be correct.")
+    assert_equal(1, GMP::GMP_RNDZ.mode, "GMP::Rnd.mode should be correct.")
+    assert_equal(2, GMP::GMP_RNDU.mode, "GMP::Rnd.mode should be correct.")
+    assert_equal(3, GMP::GMP_RNDD.mode, "GMP::Rnd.mode should be correct.")
+  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.")
+  end
+  
+  def test_rounding_ieee754
+    assert_equal("roundTiesToEven", GMP::GMP_RNDN.ieee754, "GMP::Rnd.ieee754 should be correct.")
+    assert_equal("roundTowardZero", GMP::GMP_RNDZ.ieee754, "GMP::Rnd.ieee754 should be correct.")
+    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

data/test/tc_q.rb

@@ -24,4 +24,16 @@ class TC_Q < Test::Unit::TestCase
     a = GMP::Q.new(1,2)
     assert_equal(GMP::Q.new(a), a, "GMP::Q.new(x : Q) should initialize to x")
   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.")
+    assert_equal("1/4294967296", GMP::Q(1,2**32).to_s, "GMP::Q should to_s properly.")
+    assert_equal("-22/7", GMP::Q(-22,7).to_s, "GMP::Q should to_s properly.")
+    assert_equal("-22/7", GMP::Q(22,-7).to_s, "GMP::Q should to_s properly.")
+    assert_equal("22/7", GMP::Q(-22,-7).to_s, "GMP::Q should to_s properly.")
+    assert_equal("0", GMP::Q(0,1).to_s, "GMP::Q should to_s properly.")
+    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

data/test/test_helper.rb

@@ -6,4 +6,4 @@ 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'
+require File.dirname(__FILE__) + '/../ext/gmp'

data/test/unit_tests.rb

@@ -23,11 +23,13 @@ require 'tc_division'
 require 'tc_z_jac_leg_rem'
 require 'tc_z_gcd_lcm_invert'
 require 'tc_random'
+require 'tc_hashes'
 
 begin
   GMP::MPFR_VERSION
   require 'tc_mpfr_random'
   require 'tc_mpfr_functions'
+  require 'tc_mpfr_rounding'
   require 'mpfr_tsqrt'
 rescue
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gmp
 version: !ruby/object:Gem::Version 
-  version: 0.4.3
+  version: 0.4.7
 platform: x86-mingw32
 authors: 
 - Tomasz Wegrzanowski
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-08 00:00:00 -07:00
+date: 2010-03-25 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -31,9 +31,11 @@ files:
 - ext/gmpq.c
 - ext/gmprandstate.c
 - ext/gmpz.c
+- ext/mprnd.c
 - ext/gmpf.h
 - ext/gmpq.h
 - ext/gmpz.h
+- ext/mprnd.h
 - ext/ruby_gmp.h
 - ext/takeover.h
 - ext/extconf.rb
@@ -47,9 +49,11 @@ files:
 - test/tc_floor_ceil_truncate.rb
 - test/tc_f_arithmetics_coersion.rb
 - test/tc_f_precision.rb
+- test/tc_hashes.rb
 - test/tc_logical_roots.rb
 - test/tc_mpfr_functions.rb
 - test/tc_mpfr_random.rb
+- test/tc_mpfr_rounding.rb
 - test/tc_q.rb
 - test/tc_q_basic.rb
 - test/tc_random.rb