gmp 0.6.43 → 0.6.47

data/test/gmp_troot.rb

@@ -5,6 +5,10 @@ class GMP_TRoot < Test::Unit::TestCase
   Reps = 500
 
   def one_test(root1, x2, nth, i)
+    # Travis revealed something weird on Linux. rootrem gives a different result:
+    #
+    # https://travis-ci.org/srawlins/gmp/jobs/15112258
+    skip if !RUBY_PLATFORM["darwin"]
     root2, rem2 = x2.rootrem(nth)
     temp = root1 ** nth
     temp2 = temp + rem2

data/test/mpfr_tcbrt.rb

@@ -19,7 +19,7 @@ class MPFR_TCBRT < Test::Unit::TestCase
     return 0 if exp < 0
     f.to_s[2..(index_e-1)][0,exp]
   end
-  
+
   def special
     x = @nan.cbrt(GMP::GMP_RNDN)
     assert_true(x.nan?, "@nan.cbrt should be NaN")
@@ -69,12 +69,12 @@ class MPFR_TCBRT < Test::Unit::TestCase
     y = GMP::F("1.0111E-1", 5, 2)
     assert_equal(y, x, "cbrt should be correct")
   end
-  
+
   def test_cbrt
     special
 
     (2..100).each do |p|
-      [GMP::GMP_RNDN, GMP::GMP_RNDZ, GMP::GMP_RNDD, GMP::GMP_RNDU].each do |rnd|
+      RND_MODES.each do |rnd|
         x = GMP::F(1).cbrt(rnd)
         assert_equal(GMP::F(1), x, "1.cbrt should be 1 (prec #{p}) in rounding mode #{rnd}")
         x = GMP::F(-1).cbrt(rnd)

data/test/mpfr_tconst_euler.rb

@@ -1,18 +1,6 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
 
 class MPFR_TCONST_EULER < Test::Unit::TestCase
-  def setup
-    @rand_state = GMP::RandState.new
-    
-    if GMP::MPFR_VERSION >= "3.0.0"
-      @rnd_modes = [GMP::MPFR_RNDN, GMP::MPFR_RNDZ, GMP::MPFR_RNDU, GMP::MPFR_RNDD, GMP::MPFR_RNDA]
-      @mpfr_rnd_max = 5
-    else
-      @rnd_modes = [GMP::GMP_RNDN, GMP::GMP_RNDZ, GMP::GMP_RNDU, GMP::GMP_RNDD]
-      @mpfr_rnd_max = 4
-    end
-  end
-
   def test_const_euler
     prec = 53
 
@@ -20,20 +8,23 @@ class MPFR_TCONST_EULER < Test::Unit::TestCase
     z = GMP::F("0.10010011110001000110011111100011", 32, 2)
     assert_equal(z, y, "Const Euler to precision 32 should be accurate.")
 
-    (2..200).each do |p|
-      z.prec= p
-      t = GMP::F(0, p)
-      yprec = p+10
+    (2..200).each do |prec|
+      yprec = prec + 10
 
-      #(0...@mpfr_rnd_max).each do |rnd|  # Can i emulate this?
-      (@rnd_modes).each do |rnd|
-        y.prec = yprec
-        #GMP::F.const_euler(y, rnd)
-        #err = rnd == GMP::GMP_RNDN ? yprec+1 : yprec
-        #if y.can_round?(err, rnd, rnd, p)
-        #
-        #end
+      (RND_MODES).each do |rnd|
+        y = GMP::F.const_euler(rnd, yprec)
+        err = rnd == GMP::GMP_RNDN ? yprec+1 : yprec
+
+        if y.can_round?(err, rnd, rnd, prec)
+          t = GMP::F(y, prec, rnd)
+          z = GMP::F.const_euler(rnd, prec)
+          assert_equal(t, z, "const_euler should be equal at prec=#{prec}, rnd_mode=#{rnd.inspect}")
+        end
       end
     end
   end
+
+  def test_bad_prec
+    assert_raise(TypeError) { GMP::F.const_euler(GMP::GMP_RNDN, "not a precision") }
+  end
 end

data/test/mpfr_tfac.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class MPFR_TFAC < Test::Unit::TestCase
+  def setup
+    @one = GMP::F(1)
+    @zero = GMP::F(0)
+    @inf = @one/@zero
+    @nan = @inf - @inf
+    @neg_one = GMP::F(-1)
+    @neg_inf = @neg_one/@zero
+    @neg_zero = GMP::F("-0")
+    @rand_state = GMP::RandState.new
+  end
+
+  def special
+    x = GMP::F.fac(119, GMP::GMP_RNDZ, 21)
+    y = GMP::F("0.101111101110100110110E654", 21, 2)
+    assert_equal(y, x, "fac should be correct")
+
+    x = GMP::F("0.110111100001000001101010010001000111000100000100111000010011100011011111001100011110101000111101101100110001001100110100001001111110000101010000100100011100010011101110000001000010001100010000101001111E6250", 206, 2)
+    y = GMP::F.fac(767, GMP::GMP_RNDN, 206)
+  end
+
+  def int
+    f = GMP::Z.fac(0)
+    (1..80).each do |n|
+      f = f * n
+      prec = f.size_in_base(2) - f.scan1(0)
+      (GMP::MPFR_PREC_MIN..prec).each do |p|
+        RND_MODES.each do |rnd|
+          x = GMP::F.fac(n, rnd, p)
+          y = GMP::F.new(f, p, rnd)
+          assert_equal(y, x, "fac should be correct for integers")
+        end
+      end
+    end
+  end
+
+  def test_fac
+    special
+
+    int
+
+    assert_equal(1, GMP::F.fac(0), "fac(0) should give 1")
+
+    # There are more tests in tfactorial.c, but they rely on return values and
+    # mpfr_can_round... so not yet.
+  end
+end

data/test/mpfr_tfrexp.rb

@@ -0,0 +1,47 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class MPFR_TFrexp < Test::Unit::TestCase
+  def setup
+  end
+
+  def special
+    exp, y = GMP::F.nan.frexp
+    assert_true(y.nan?, "frexp of NaN should be correct")
+
+    exp, y = GMP::F.inf.frexp
+    assert_true(y.infinite? && y > 0, "frexp of Inf should be correct")
+
+    exp, y = GMP::F.inf(-1).frexp
+    assert_true(y.infinite? && y < 0, "frexp of -Inf should be correct")
+
+    exp, y = GMP::F.zero.frexp
+    assert_equal(y, GMP::F.zero, "frexp of zero should be correct")
+
+    exp, y = GMP::F.zero(-1).frexp
+    assert_equal(y, GMP::F.zero(-1), "frexp of -zero should be correct")
+
+    exp, y = GMP::F(17).frexp
+    assert_equal(exp, 5, "frexp of 17 should return exp of 5")
+    assert_equal(y, GMP::F("0.53125"), "frexp of 17 should return exp of 5")
+
+    exp, y = GMP::F(17).frexp(GMP::GMP_RNDN, 4)
+    assert_equal(exp, 5, "frexp of 17 should return exp of 5")
+    assert_equal(y, GMP::F("0.5", 4), "frexp of 17 should return exp of 5")
+
+    exp, y = GMP::F(17).frexp(GMP::GMP_RNDZ, 4)
+    assert_equal(exp, 5, "frexp of 17 should return exp of 5")
+    assert_equal(y, GMP::F("0.5", 4), "frexp of 17 should return exp of 5")
+
+    exp, y = GMP::F(17).frexp(GMP::GMP_RNDD, 4)
+    assert_equal(exp, 5, "frexp of 17 should return exp of 5")
+    assert_equal(y, GMP::F("0.5", 4), "frexp of 17 should return exp of 5")
+
+    exp, y = GMP::F(17).frexp(GMP::GMP_RNDU, 4)
+    assert_equal(exp, 5, "frexp of 17 should return exp of 5")
+    assert_equal(y, GMP::F("0.562", 4), "frexp of 17 should return exp of 5")
+  end
+
+  def test_fac
+    special
+  end
+end

data/test/tc_f_abs_neg.rb

@@ -0,0 +1,28 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class TC_f_abs_neg < Test::Unit::TestCase
+  def setup
+    @a=GMP::F.new(3.14)
+    @b=GMP::F.new()
+    @c=GMP::F.new(-3.14)
+    @d=GMP::F.new(3.14)
+    @e=GMP::F.new()
+    @f=GMP::F.new(-3.14)
+  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().")
+    @d.neg!; @e.neg!; @f.neg!
+    assert_equal(@d, @c,                                         "(x : GMP::Z).neg! should be calculated correctly.")
+    assert_equal(@e, @b,                                         "(x : GMP::Z).neg! should be calculated correctly.")
+    assert_equal(@f, @a,                                         "GMP::Z.new().neg! should equal GMP::Z.new().")
+  end
+
+  def test_abs
+    assert_equal([@a, 0, @a], [@a.abs, @b.abs, @c.abs],          "(x : GMP::Z).abs should be calculated correctly.")
+    @a.abs!; @b.abs!; @c.abs!
+    assert_equal([@a, 0, @a], [@a, @b, @c],                      "(x : GMP::Z).abs! should be calculated correctly.")
+  end
+end

data/test/tc_f_to_s.rb

@@ -10,7 +10,6 @@ class TC_F_to_s < Test::Unit::TestCase
   end
 
   def test_to_s_default_prec
-    return if not GMP.const_defined? :MPFR_VERSION  # I might be able to add this one back in...
     rs = GMP::RandState.new(11213)
     if GMP.const_defined? :MPFR_VERSION
       strings = [
@@ -26,7 +25,7 @@ class TC_F_to_s < Test::Unit::TestCase
       ]
     end
     # In this test, each numerator, n, and denominator, d, pair is generated in
-    # succession from @rs. Each pair is used to create a floating point number.
+    # succession from rs. Each pair is used to create a floating point number.
     # The first pair are uniformly distributed random integers between 0 and
     # 2^100 - 1. The next two are distributed between 0 and 2^110 - 1. The last
     # are distributed between 0 and 2^190 - 1.
@@ -59,20 +58,35 @@ class TC_F_to_s < Test::Unit::TestCase
   end
 
   def test_different_bases
-    return if not GMP.const_defined? :MPFR_VERSION
     f = GMP::F(0.5)
-    assert_equal("0.50000000000000000e+0",                                     f.to_s)
-    assert_equal("0.10000000000000000000000000000000000000000000000000000e+0", f.to_s(2))
-    assert_equal("0.10000000000000000000000000000000000000000000000000000e+0", f.to_s(:bin))
-    assert_equal("0.11111111111111111111111111111111112e+0",                   f.to_s(3))
-    assert_equal("0.200000000000000000000000000e+0",                           f.to_s(4))
-    assert_equal("0.50000000000000000e+0",                                     f.inspect)
-
     g = GMP::F(0.8)
-    assert_equal("0.80000000000000004e+0",                   g.to_s)
-    assert_equal("0.21012101210121012101210121012101220e+0", g.to_s(3))
-    assert_equal("0.400000000000000000000003e+0",            g.to_s(5))
-    assert_equal("0.k00000000002ge+0",                       g.to_s(25))
-    assert_equal("0.80000000000000004e+0",                   g.inspect)
+
+    if GMP.const_defined? :MPFR_VERSION
+      assert_equal("0.50000000000000000e+0",                                     f.to_s)
+      assert_equal("0.10000000000000000000000000000000000000000000000000000e+0", f.to_s(2))
+      assert_equal("0.10000000000000000000000000000000000000000000000000000e+0", f.to_s(:bin))
+      assert_equal("0.11111111111111111111111111111111112e+0",                   f.to_s(3))
+      assert_equal("0.200000000000000000000000000e+0",                           f.to_s(4))
+      assert_equal("0.50000000000000000e+0",                                     f.inspect)
+
+      assert_equal("0.80000000000000004e+0",                   g.to_s)
+      assert_equal("0.21012101210121012101210121012101220e+0", g.to_s(3))
+      assert_equal("0.400000000000000000000003e+0",            g.to_s(5))
+      assert_equal("0.k00000000002ge+0",                       g.to_s(25))
+      assert_equal("0.80000000000000004e+0",                   g.inspect)
+    else
+      assert_equal("0.5e+0",                                          f.to_s)
+      assert_equal("0.1e+0",                                          f.to_s(2))
+      assert_equal("0.1e+0",                                          f.to_s(:bin))
+      assert_equal("0.111111111111111111111111111111111111111111e+0", f.to_s(3))
+      assert_equal("0.2e+0",                                          f.to_s(4))
+      assert_equal("0.5e+0",                                          f.inspect)
+
+      assert_equal("0.800000000000000044409e+0",                     g.to_s)
+      assert_equal("0.21012101210121012101210121012101212211012e+0", g.to_s(3))
+      assert_equal("0.40000000000000000000000231042e+0",             g.to_s(5))
+      assert_equal("0.k00000000002g49e+0",                           g.to_s(25))
+      assert_equal("0.800000000000000044409e+0",                     g.inspect)
+    end
   end
 end

data/test/tc_mpfr_cmp.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class TC_MPFR_Cmp < Test::Unit::TestCase
+  def setup
+    @neg_inf = GMP::F(0).log  # -Inf
+    @inf = -@neg_inf          # Inf
+    @nan = @neg_inf + @inf    # NaN
+  end
+
+  def test_mpfr_lessgreater
+    assert_true(GMP::F(5).lessgreater?(GMP::F(12)), "lessgreater? should work")
+    assert_true(GMP::F(5).lessgreater?(@inf), "lessgreater? should work")
+    assert_false(GMP::F(5).lessgreater?(@nan), "lessgreater? should work")
+    assert_false(@nan.lessgreater?(@nan), "lessgreater? should work")
+  end
+
+  def test_mpfr_lessgreater_types
+    assert_raise(TypeError) { GMP::F(5).lessgreater? 3.14 }
+  end
+
+  def test_mpfr_unordered
+    assert_true(@nan.unordered?(GMP::F(5)), "unordered? should work")
+    assert_false(@neg_inf.unordered?(GMP::F(5)), "unordered? should work")
+  end
+
+  def test_mpfr_unordered_types
+    assert_raise(TypeError) { GMP::F(5).unordered? 3.14 }
+  end
+end

data/test/tc_mpfr_inf_nan_zero.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class TC_MPFR_Inf_Nan_Zero < Test::Unit::TestCase
+  def setup
+    @neg_inf = GMP::F(0).log  # -Inf
+    @inf = -@neg_inf          # Inf
+    @nan = @neg_inf + @inf    # NaN
+    @zero = GMP::F(0)
+  end
+
+  def test_nan
+    assert_equal(@nan, GMP::F.nan, "NaN should be NaN")
+  end
+
+  def test_inf
+    assert_equal(@inf, GMP::F.inf, "inf should be inf")
+    assert_equal(@neg_inf, GMP::F.inf(-1), "neg_inf should be neg_inf")
+  end
+
+  def test_zero
+    assert_equal(@zero, GMP::F.zero, "zero should be zero")
+    assert_equal(-@zero, GMP::F.zero(-1), "negaitve zero should be negative zero")
+  end
+
+  def test_type
+    assert_raise(TypeError) { GMP::F.inf(0.5); }
+    assert_raise(TypeError) { GMP::F.zero(0.5); }
+  end
+end

data/test/tc_mpfr_new_rounding.rb

@@ -0,0 +1,126 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'test_helper'))
+
+class TC_MPFR_New_Rounding < Test::Unit::TestCase
+  def test_new_fixnum
+    ninety_six = GMP::F(96, 4)
+    one_hundred_four = GMP::F(104, 4)
+
+    a = GMP::F(100, 4)
+    assert_equal(a, ninety_six, "GMP::F.new should default round with RNDN")
+
+    a = GMP::F(100, 4, GMP::GMP_RNDN)
+    assert_equal(a, ninety_six, "GMP::F.new should round with RNDN")
+
+    a = GMP::F(100, 4, GMP::GMP_RNDD)
+    assert_equal(a, ninety_six, "GMP::F.new should round with RNDD")
+
+    a = GMP::F(100, 4, GMP::GMP_RNDZ)
+    assert_equal(a, ninety_six, "GMP::F.new should round with RNDZ")
+
+    a = GMP::F(100, 4, GMP::GMP_RNDU)
+    assert_equal(a, one_hundred_four, "GMP::F.new should round with RNDU")
+  end
+
+  def test_new_bignum
+    over = GMP::F(0.36472996384e+20, 32)
+    under = GMP::F(0.36472996375e+20, 32)
+
+    a = GMP::F(3**41, 32)
+    assert_equal(a, under, "GMP::F.new should default round with RNDN")
+
+    a = GMP::F(3**41, 32, GMP::GMP_RNDN)
+    assert_equal(a, under, "GMP::F.new should round with RNDN")
+
+    a = GMP::F(3**41, 32, GMP::GMP_RNDD)
+    assert_equal(a, under, "GMP::F.new should round with RNDD")
+
+    a = GMP::F(3**41, 32, GMP::GMP_RNDZ)
+    assert_equal(a, under, "GMP::F.new should round with RNDZ")
+
+    a = GMP::F(3**41, 32, GMP::GMP_RNDU)
+    assert_equal(a, over, "GMP::F.new should round with RNDU")
+  end
+
+  def test_new_gmpz
+    z100 = GMP::Z(100)
+    ninety_six = GMP::F(96, 4)
+    one_hundred_four = GMP::F(104, 4)
+
+    a = GMP::F(z100, 4)
+    assert_equal(a, ninety_six, "GMP::F.new should default round with RNDN")
+
+    a = GMP::F(z100, 4, GMP::GMP_RNDN)
+    assert_equal(a, ninety_six, "GMP::F.new should round with RNDN")
+
+    a = GMP::F(z100, 4, GMP::GMP_RNDD)
+    assert_equal(a, ninety_six, "GMP::F.new should round with RNDD")
+
+    a = GMP::F(z100, 4, GMP::GMP_RNDZ)
+    assert_equal(a, ninety_six, "GMP::F.new should round with RNDZ")
+
+    a = GMP::F(z100, 4, GMP::GMP_RNDU)
+    assert_equal(a, one_hundred_four, "GMP::F.new should round with RNDU")
+  end
+
+  def test_new_gmpq
+    pi = GMP::Q(22,7)
+    below = GMP::F(0.3141e+1, 8)
+    above = GMP::F(0.3156e+1, 8)
+
+    a = GMP::F(pi, 8)
+    assert_equal(a, below, "GMP::F.new should default round with RNDN")
+
+    a = GMP::F(pi, 8, GMP::GMP_RNDN)
+    assert_equal(a, below, "GMP::F.new should round with RNDN")
+
+    a = GMP::F(pi, 8, GMP::GMP_RNDD)
+    assert_equal(a, below, "GMP::F.new should round with RNDD")
+
+    a = GMP::F(pi, 8, GMP::GMP_RNDZ)
+    assert_equal(a, below, "GMP::F.new should round with RNDZ")
+
+    a = GMP::F(pi, 8, GMP::GMP_RNDU)
+    assert_equal(a, above, "GMP::F.new should round with RNDU")
+  end
+
+  def test_new_float
+    ohoh977 = GMP::F(0.977e-2, 4)
+    oh107 = GMP::F(0.107e-1, 4)
+
+    a = GMP::F(0.01, 4)
+    assert_equal(a, ohoh977, "GMP::F.new should default round with RNDN")
+
+    a = GMP::F(0.01, 4, GMP::GMP_RNDN)
+    assert_equal(a, ohoh977, "GMP::F.new should round with RNDN")
+
+    a = GMP::F(0.01, 4, GMP::GMP_RNDD)
+    assert_equal(a, ohoh977, "GMP::F.new should round with RNDD")
+
+    a = GMP::F(0.01, 4, GMP::GMP_RNDZ)
+    assert_equal(a, ohoh977, "GMP::F.new should round with RNDZ")
+
+    a = GMP::F(0.01, 4, GMP::GMP_RNDU)
+    assert_equal(a, oh107, "GMP::F.new should round with RNDU")
+  end
+
+  def test_new_mpfr
+    ohoh977 = GMP::F(-0.977e-2, 4)
+    oh107 = GMP::F(-0.107e-1, 4)
+    one_hundredth = GMP::F(-0.01)
+
+    a = GMP::F(one_hundredth, 4)
+    assert_equal(a, ohoh977, "GMP::F.new should default round with RNDN")
+
+    a = GMP::F(one_hundredth, 4, GMP::GMP_RNDN)
+    assert_equal(a, ohoh977, "GMP::F.new should round with RNDN")
+
+    a = GMP::F(one_hundredth, 4, GMP::GMP_RNDD)
+    assert_equal(a, oh107, "GMP::F.new should round with RNDD")
+
+    a = GMP::F(one_hundredth, 4, GMP::GMP_RNDZ)
+    assert_equal(a, ohoh977, "GMP::F.new should round with RNDZ")
+
+    a = GMP::F(one_hundredth, 4, GMP::GMP_RNDU)
+    assert_equal(a, ohoh977, "GMP::F.new should round with RNDU")
+  end
+end