gnu_mpc 0.8.0

data/spec/atan_spec.rb

@@ -0,0 +1,109 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+# All tests adapted from MPC 1.0.1's tests/atan.dat
+describe MPC, '#atan' do
+  it 'should calculate the inverse tangent of a pure real argument' do
+    data = [
+      [["-0x16DCC57BB565FDp-52", 53, 16], [0], MPC.new([GMP::F(-7    ), -GMP::F(0)])],
+      [["-0x1F730BD281F69Bp-53", 53, 16], [0], MPC.new([GMP::F(-1.5  ), -GMP::F(0)])],
+      [["-0x1921FB54442D18p-53", 53, 16], [0], MPC.new([GMP::F(-1    ), -GMP::F(0)])],
+      [["-0x1700A7C5784634p-53", 53, 16], [0], MPC.new([GMP::F(-0.875), -GMP::F(0)])],
+      [["-0x1FD5BA9AAC2F6Ep-56", 53, 16], [0], MPC.new([GMP::F(-0.125), -GMP::F(0)])],
+      [[ "0x1FD5BA9AAC2F6Ep-56", 53, 16], [0], MPC.new([GMP::F( 0.125), -GMP::F(0)])],
+      [[ "0x1700A7C5784634p-53", 53, 16], [0], MPC.new([GMP::F( 0.875), -GMP::F(0)])],
+      [[ "0x1921FB54442D18p-53", 53, 16], [0], MPC.new([GMP::F( 1    ), -GMP::F(0)])],
+      [[ "0x1F730BD281F69Bp-53", 53, 16], [0], MPC.new([GMP::F( 1.5  ), -GMP::F(0)])],
+      [[ "0x16DCC57BB565FDp-52", 53, 16], [0], MPC.new([GMP::F( 7    ), -GMP::F(0)])]
+    ]
+    data.each do |expected_real, expected_imag, input|
+      actual = input.atan
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+
+  it 'should calculate the inverse tangent of a pure imaginary argument' do
+    data = [
+      [["-0x1921FB54442D18p-52", 53, 16], ["-0x1269621134DB92p-55", 53, 16], MPC.new([-GMP::F(0), GMP::F(-7    )])],
+      [[ "0x1921FB54442D18p-52", 53, 16], ["-0x1269621134DB92p-55", 53, 16], MPC.new([ GMP::F(0), GMP::F(-7    )])],
+      [["-0x1921FB54442D18p-52", 53, 16], ["-0x19C041F7ED8D33p-53", 53, 16], MPC.new([-GMP::F(0), GMP::F(-1.5  )])],
+      [[ "0x1921FB54442D18p-52", 53, 16], ["-0x19C041F7ED8D33p-53", 53, 16], MPC.new([ GMP::F(0), GMP::F(-1.5  )])],
+      [[0],                               ["-0x15AA16394D481Fp-52", 53, 16], MPC.new([-GMP::F(0), GMP::F(-0.875)])],
+      [[0],                               ["-0x1015891C9EAEF7p-55", 53, 16], MPC.new([-GMP::F(0), GMP::F(-0.125)])],
+      [[0],                               [ "0x1015891C9EAEF7p-55", 53, 16], MPC.new([-GMP::F(0), GMP::F( 0.125)])],
+      [[0],                               [ "0x15AA16394D481Fp-52", 53, 16], MPC.new([-GMP::F(0), GMP::F( 0.875)])],
+      [[ "0x1921FB54442D18p-52", 53, 16], [ "0x19C041F7ED8D33p-53", 53, 16], MPC.new([ GMP::F(0), GMP::F( 1.5  )])],
+      [["-0x1921FB54442D18p-52", 53, 16], [ "0x19C041F7ED8D33p-53", 53, 16], MPC.new([-GMP::F(0), GMP::F( 1.5  )])],
+      [[ "0x1921FB54442D18p-52", 53, 16], [ "0x1269621134DB92p-55", 53, 16], MPC.new([ GMP::F(0), GMP::F( 7    )])],
+      [["-0x1921FB54442D18p-52", 53, 16], [ "0x1269621134DB92p-55", 53, 16], MPC.new([-GMP::F(0), GMP::F( 7    )])],
+      [[0],                               [ "0x1FFFFFFFFFFF82p-52", 53, 16], MPC.new([ GMP::F(0), GMP::F("0x1ED9505E1BC3C2p-53", 53, 16)])]
+    ]
+    data.each do |expected_real, expected_imag, input|
+      actual = input.atan
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+
+  it 'should calculate the inverse tangent of a pure imaginary argument, 512 precision' do
+    input = MPC.new([
+      GMP::F(0, 512),
+      GMP::F("0x1018734E311AB77B710F9212969B3C86E8F388BB7DA5BAF74ADE078F43D96456D088C8A0B2A370159DFB8D4A4BC51BCDA91F2DCD01B2EC610C62AA33FAD1688p-504", 512, 16)
+    ], 512)
+    actual = input.atan(MPC::MPC_RNDNZ, 512, 512)
+    actual.real.should eq GMP::F.new("0x6487ED5110B4611A62633145C06E0E68948127044533E63A0105DF531D89CD9128A5043CC71A026EF7CA8CD9E69D218D98158536F92F8A1BA7F09AB6B6A8E123p-510", 512, 16)
+    actual.imag.should eq GMP::F.new("0x5D137113B914461DA3202D77346EE4980DA5FD0BAD68F5A7928DCA9F632750D9BFFA00654C523929F15DED554EC6BC476DB2C46FA433E569227085E0BDEA86FFp-509", 512, 16)
+  end
+
+  it 'should calculate the inverse tangent of a pure imaginary argument, 12 precision' do
+    input = MPC.new([
+      GMP::F(0, 12),
+      GMP::F("0x9380000000", 12, 16)
+    ], 12)
+    actual = input.atan
+    actual.real.should eq GMP::F.new("0xC91p-11", 12, 16)
+    actual.imag.should eq GMP::F.new("0x6F1p-50", 12, 16)
+  end
+
+  it 'should calculate the inverse tangent of a general inputs' do
+    data = [
+      [["0x91EA521228BFC46ACAp-118", 72, 16], ["-0x9E96A01DBAD6470974p-73", 72, 16], ["0x84C3E02A5C6DEE8410p-118", 72, 16], ["-0x99B43C52A95A21C220p-73", 72, 16], MPC::MPC_RNDUN],
+      [["0x91EA521228BFC46AC9p-118", 72, 16], ["-0x9E96A01DBAD6470974p-73", 72, 16], ["0x84C3E02A5C6DEE8410p-118", 72, 16], ["-0x99B43C52A95A21C220p-73", 72, 16], MPC::MPC_RNDDD],
+      [["0x91EA521228BFC46AC9p-118", 72, 16], ["-0x9E96A01DBAD6470973p-73", 72, 16], ["0x84C3E02A5C6DEE8410p-118", 72, 16], ["-0x99B43C52A95A21C220p-73", 72, 16], MPC::MPC_RNDDU],
+      [["0x91EA521228BFC46ACAp-118", 72, 16], [ "0x9E96A01DBAD6470974p-73", 72, 16], ["0x84C3E02A5C6DEE8410p-118", 72, 16], [ "0x99B43C52A95A21C220p-73", 72, 16], MPC::MPC_RNDUN],
+      [["0x91EA521228BFC46AC9p-118", 72, 16], [ "0x9E96A01DBAD6470974p-73", 72, 16], ["0x84C3E02A5C6DEE8410p-118", 72, 16], [ "0x99B43C52A95A21C220p-73", 72, 16], MPC::MPC_RNDDU],
+      [["0x91EA521228BFC46AC9p-118", 72, 16], [ "0x9E96A01DBAD6470973p-73", 72, 16], ["0x84C3E02A5C6DEE8410p-118", 72, 16], [ "0x99B43C52A95A21C220p-73", 72, 16], MPC::MPC_RNDDD],
+    ]
+    data.each do |expected_real, expected_imag, input_real, input_imag, rounding_mode|
+      actual = MPC.new([GMP::F(*input_real), GMP::F(*input_imag)], 72).atan(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+
+  it 'should calculate the inverse tangent of a general inputs, 156 precision' do
+    input = MPC.new([
+      GMP::F("-0xF0CE58073F866A53F25DB85DE8D503FBDD81051p-109", 156, 16),
+      GMP::F( "0xCF81D7C76BB9754A52056CB0F144B0C6700CC8Cp-128", 156, 16)
+    ], 156)
+    actual = input.atan
+    actual.real.should eq GMP::F.new("-0xC90FDAA22167B20DB08A0C3B1FF415CABE49624p-155", 156, 16)
+    actual.imag.should eq GMP::F.new("0xEA84E971BD52E49CCEE036E303D5ECB2D9D9B9Ap-222", 156, 16)
+  end
+
+  it 'should calculate the inverse tangent of a general inputs, 2 precision' do
+    actual = MPC.new([GMP::F("0x1p-7", 2, 16), GMP::F(-1, 2, 16)], 2).atan
+    actual.real.should eq GMP::F.new( 0.75, 2, 16)
+    actual.imag.should eq GMP::F.new(-3,    2, 16)
+
+    actual = MPC.new([GMP::F("0x1p-7", 2, 16), GMP::F(1, 2, 16)], 2).atan
+    actual.real.should eq GMP::F.new( 0.75, 2, 16)
+    actual.imag.should eq GMP::F.new( 3,    2, 16)
+  end
+
+  it 'should calculate the inverse tangent: "improve test coverage"' do
+    actual = MPC.new([GMP::F("-0xa.529626a89a1960@23", 57, 16), GMP::F("-0x3.9a5472b5709e74@14", 57, 16)], 57).atan
+    actual.real.should eq GMP::F.new("-0x1.921fb54442d184", 57, 16)
+    actual.imag.should eq GMP::F.new("-0x8.a7e33db93ecf18@-34", 57, 16)
+  end
+end

data/spec/conj_spec.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+# All tests adapted from MPC 1.0.1's tests/conj.dat
+describe MPC, '#conj' do
+  it 'should calculate the conjugate of a pure real number' do
+    data = [
+      [[ "0x123456789abcdep+52", 53, 16], [ 0,  2], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0, 17)]), MPC::MPC_RNDNN],
+      [["-0x123456789abcdep+52", 53, 16], [ 0,  3], MPC.new([GMP::F("-0x123456789abcdep+52", 53, 16), GMP::F(0, 16)]), MPC::MPC_RNDZN],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0,  4], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0, 15)]), MPC::MPC_RNDUN],
+      [["-0x123456789abcdep+52", 53, 16], [ 0,  5], MPC.new([GMP::F("-0x123456789abcdep+52", 53, 16), GMP::F(0, 14)]), MPC::MPC_RNDDN],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0,  6], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0, 13)]), MPC::MPC_RNDZZ],
+      [["-0x123456789abcdep+52", 53, 16], [ 0,  7], MPC.new([GMP::F("-0x123456789abcdep+52", 53, 16), GMP::F(0, 12)]), MPC::MPC_RNDUZ],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0,  8], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0, 11)]), MPC::MPC_RNDDZ],
+      [["-0x123456789abcdep+52", 53, 16], [ 0,  9], MPC.new([GMP::F("-0x123456789abcdep+52", 53, 16), GMP::F(0, 10)]), MPC::MPC_RNDNZ],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0, 10], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0,  9)]), MPC::MPC_RNDUU],
+      [["-0x123456789abcdep+52", 53, 16], [ 0, 11], MPC.new([GMP::F("-0x123456789abcdep+52", 53, 16), GMP::F(0,  8)]), MPC::MPC_RNDDU],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0, 12], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0,  7)]), MPC::MPC_RNDNU],
+      [["-0x123456789abcdep+52", 53, 16], [ 0, 13], MPC.new([GMP::F("-0x123456789abcdep+52", 53, 16), GMP::F(0,  6)]), MPC::MPC_RNDZU],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0, 14], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0,  5)]), MPC::MPC_RNDDD],
+      [["-0x123456789abcdep+52", 53, 16], [ 0, 15], MPC.new([GMP::F("-0x123456789abcdep+52", 53, 16), GMP::F(0,  4)]), MPC::MPC_RNDND],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0, 16], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0,  3)]), MPC::MPC_RNDZD],
+      [["-0x123456789abcdep+52", 53, 16], [ 0, 17], MPC.new([GMP::F("-0x123456789abcdep+52", 53, 16), GMP::F(0,  2)]), MPC::MPC_RNDUD],
+    ]
+    data.each do |expected_real, expected_imag, input, rounding_mode|
+      actual = input.conj(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+
+  it 'should calculate the conjugate of a pure imaginary argument' do
+    data = [
+      [[0, 53], ["-0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 53), GMP::F( "0x123456789abcdep+52", 53, 16)]), MPC::MPC_RNDNN],
+      [[0, 53], ["-0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 51), GMP::F( "0x123456789abcdep+52", 54, 16)]), MPC::MPC_RNDZN],
+      [[0, 53], [ "0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 49), GMP::F("-0x123456789abcdep+52", 55, 16)]), MPC::MPC_RNDUN],
+      [[0, 53], [ "0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 47), GMP::F("-0x123456789abcdep+52", 56, 16)]), MPC::MPC_RNDUN],
+      [[0, 53], ["-0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 45), GMP::F( "0x123456789abcdep+52", 57, 16)]), MPC::MPC_RNDZZ],
+      [[0, 53], ["-0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 43), GMP::F( "0x123456789abcdep+52", 58, 16)]), MPC::MPC_RNDUZ],
+      [[0, 53], [ "0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 41), GMP::F("-0x123456789abcdep+52", 59, 16)]), MPC::MPC_RNDDZ],
+      [[0, 53], [ "0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 39), GMP::F("-0x123456789abcdep+52", 60, 16)]), MPC::MPC_RNDNZ],
+      [[0, 53], ["-0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 37), GMP::F( "0x123456789abcdep+52", 61, 16)]), MPC::MPC_RNDUU],
+      [[0, 53], ["-0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 35), GMP::F( "0x123456789abcdep+52", 62, 16)]), MPC::MPC_RNDDU],
+      [[0, 53], [ "0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 33), GMP::F("-0x123456789abcdep+52", 63, 16)]), MPC::MPC_RNDNU],
+      [[0, 53], [ "0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 31), GMP::F("-0x123456789abcdep+52", 64, 16)]), MPC::MPC_RNDZU],
+      [[0, 53], ["-0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 29), GMP::F( "0x123456789abcdep+52", 65, 16)]), MPC::MPC_RNDDD],
+      [[0, 53], ["-0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 27), GMP::F( "0x123456789abcdep+52", 66, 16)]), MPC::MPC_RNDND],
+      [[0, 53], [ "0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 25), GMP::F("-0x123456789abcdep+52", 67, 16)]), MPC::MPC_RNDZD],
+      [[0, 53], [ "0x123456789abcdep+52", 53, 16], MPC.new([GMP::F(0, 23), GMP::F("-0x123456789abcdep+52", 68, 16)]), MPC::MPC_RNDUD]
+    ]
+    data.each do |expected_real, expected_imag, input, rounding_mode|
+      actual = input.conj(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+end

data/spec/cos_spec.rb

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+# All tests adapted from MPC 1.0.1's tests/cos.dat
+describe MPC, '#cos' do
+  it 'should calculate the cosine of a pure real argument' do
+    data = [
+      ["0x8a51407da8344p-52",   MPC.new([GMP::F(-1, 7), GMP::F(0, 7)])],
+      ["0x8a51407da8344p-52",   MPC.new([GMP::F( 1, 7), GMP::F(0, 7)])]
+    ]
+    data.each do |expected, input|
+      actual = input.cos(MPC::MPC_RNDNN, 50, 50)
+      actual.real.should eq GMP::F.new(expected, 50, 16)
+      actual.imag.should eq GMP::F(0)
+    end
+  end
+
+  it 'should calculate the cosine of a pure imaginary argument' do
+    data = [
+      ["0x18b07551d9f55p-48",   MPC.new([GMP::F(0, 7), GMP::F(-1, 7)])],
+      ["0x18b07551d9f55p-48",   MPC.new([GMP::F(0, 7), GMP::F( 1, 7)])]
+    ]
+    data.each do |expected, input|
+      actual = input.cos(MPC::MPC_RNDNN, 50, 50)
+      actual.real.should eq GMP::F.new(expected, 50, 16)
+      actual.imag.should eq GMP::F(0)
+    end
+  end
+
+  it 'should calculate the cosine of an argument with +1 and -1' do
+    data = [
+      ["0xd56f54b7a1accp-52", "-0xfd28666957478p-52",  MPC.new([GMP::F(-1, 7), GMP::F(-1, 7)])],
+      ["0xd56f54b7a1accp-52",  "0xfd28666957478p-52",  MPC.new([GMP::F(-1, 7), GMP::F( 1, 7)])],
+      ["0xd56f54b7a1accp-52",  "0xfd28666957478p-52",  MPC.new([GMP::F( 1, 7), GMP::F(-1, 7)])],
+      ["0xd56f54b7a1accp-52", "-0xfd28666957478p-52",  MPC.new([GMP::F( 1, 7), GMP::F( 1, 7)])]
+    ]
+    data.each do |expected_real, expected_imag, input|
+      actual = input.cos(MPC::MPC_RNDNN, 50, 50)
+      actual.real.should eq GMP::F.new(expected_real, 50, 16)
+      actual.imag.should eq GMP::F.new(expected_imag, 50, 16)
+    end
+  end
+
+  it 'should calculate the cosine of ieee-754 double precision numbers' do
+    data = [
+      [[514],                            [0], [0], ["0x1BBDD1808C59A3p-50", 53, 16], MPC::MPC_RNDNN],
+      [["0x100FFFFFFFFFFFp-43", 53, 16], [0], [0], ["0x1BBDD1808C59A3p-50", 53, 16], MPC::MPC_RNDDD],
+    ]
+    data.each do |expected_real, expected_imag, input_real, input_imag, rounding_mode|
+      actual = MPC.new([GMP::F.new(*input_real), GMP::F.new(*input_imag)]).cos(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+end

data/spec/cosh_spec.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+# All tests adapted from MPC 1.0.1's tests/cosh.dat
+describe MPC, '#cosh' do
+  it 'should calculate the hyperbolic cosine of special values' do
+    data = [
+      [1,   MPC.new([GMP::F(0, 2), GMP::F(0, 2)])]
+    ]
+    data.each do |expected, input|
+      actual = input.cosh(MPC::MPC_RNDNN, 2, 2)
+      actual.real.should eq GMP::F.new(expected, 2)
+      actual.imag.should eq GMP::F(0)
+    end
+  end
+
+  it 'should calculate the hyperbolic sine of ieee-754 double precision numbers' do
+    data = [
+      [["0x10000000000001p-53", 53, 16], ["0x10000000000001p-52", 53, 16], ["0x1DA2E1BD2C9EBCp-53", 53, 16], ["0x138AADEA15829Fp-52", 53, 16], MPC::MPC_RNDNN],
+    ]
+    data.each do |expected_real, expected_imag, input_real, input_imag, rounding_mode|
+      actual = MPC.new([GMP::F.new(*input_real), GMP::F.new(*input_imag)]).cosh(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+end

data/spec/exp_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+# All tests adapted from MPC 1.0.1's tests/exp.dat
+describe MPC, '#exp' do
+  it 'should calculate the exponential of a pure real number' do
+    data = [
+      [["0x1936dc5690c08fp-44", 53, 16], [ 0,  2], MPC.new([GMP::F( 6, 53),  GMP::F(0, 17)]), MPC::MPC_RNDNN],
+      [["0x4b0556e084f3d0p-60", 53, 16], [ 0,  3], MPC.new([GMP::F(-4, 54),  GMP::F(0, 16)]), MPC::MPC_RNDZN],
+      [["0xec7325c6a6ed70p-53", 53, 16], [ 0,  4], MPC.new([GMP::F( 2, 55),  GMP::F(0, 15)]), MPC::MPC_RNDUN],
+      [["0x178b56362cef37p-54", 53, 16], [ 0,  5], MPC.new([GMP::F(-1, 56),  GMP::F(0, 14)]), MPC::MPC_RNDDN],
+      [["0x3699205c4e74b0p-48", 53, 16], [ 0,  6], MPC.new([GMP::F( 4, 57),  GMP::F(0, 13)]), MPC::MPC_RNDZZ],
+      [["0x454aaa8efe0730p-57", 53, 16], [ 0,  7], MPC.new([GMP::F(-2, 58),  GMP::F(0, 12)]), MPC::MPC_RNDUZ],
+      [["0x15bf0a8b145769p-51", 53, 16], [ 0,  8], MPC.new([GMP::F( 1, 59),  GMP::F(0, 11)]), MPC::MPC_RNDDZ],
+      [["0xa2728f889ea6b0p-64", 53, 16], [ 0,  9], MPC.new([GMP::F(-6, 60),  GMP::F(0, 10)]), MPC::MPC_RNDNZ],
+      [["0xec7325c6a6ed70p-53", 53, 16], [ 0, 10], MPC.new([GMP::F( 2, 61),  GMP::F(0,  9)]), MPC::MPC_RNDUU],
+      [["0x178b56362cef37p-54", 53, 16], [ 0, 11], MPC.new([GMP::F(-1, 62),  GMP::F(0,  8)]), MPC::MPC_RNDDU],
+      [["0x1936dc5690c08fp-44", 53, 16], [ 0, 12], MPC.new([GMP::F( 6, 63),  GMP::F(0,  7)]), MPC::MPC_RNDNU],
+      [["0x4b0556e084f3d0p-60", 53, 16], [ 0, 13], MPC.new([GMP::F(-4, 64),  GMP::F(0,  6)]), MPC::MPC_RNDZU],
+      [["0x15bf0a8b145769p-51", 53, 16], [ 0, 14], MPC.new([GMP::F( 1, 65),  GMP::F(0,  5)]), MPC::MPC_RNDDD],
+      [["0xa2728f889ea6b0p-64", 53, 16], [ 0, 15], MPC.new([GMP::F(-6, 66),  GMP::F(0,  4)]), MPC::MPC_RNDND],
+      [["0x3699205c4e74b0p-48", 53, 16], [ 0, 16], MPC.new([GMP::F( 4, 66),  GMP::F(0,  3)]), MPC::MPC_RNDZD],
+      [["0x454aaa8efe0730p-57", 53, 16], [ 0, 17], MPC.new([GMP::F(-2, 66),  GMP::F(0,  2)]), MPC::MPC_RNDUD]
+    ]
+    data.each do |expected_real, expected_imag, input, rounding_mode|
+      actual = input.exp(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+
+  it 'should calculate the exponential of a pure imaginary number' do
+    data = [
+      [[ "0x1eb9b7097822f5p-53", 53, 16], ["-0x4787c62ac28b0p-52",  53, 16], MPC.new([GMP::F(0,53), GMP::F( 6, 53)]), MPC::MPC_RNDNN],
+      [["-0x53aa981b6c9300p-55", 53, 16], ["-0xc1bdceeee0f57p-52",  53, 16], MPC.new([GMP::F(0,51), GMP::F( 4, 54)]), MPC::MPC_RNDZN],
+      [["-0x6a88995d4dc810p-56", 53, 16], ["-0xe8c7b7568da23p-52",  53, 16], MPC.new([GMP::F(0,49), GMP::F(-2, 55)]), MPC::MPC_RNDUN],
+      [[ "0x114a280fb5068bp-53", 53, 16], ["-0xd76aa47848677p-52",  53, 16], MPC.new([GMP::F(0,47), GMP::F(-1, 56)]), MPC::MPC_RNDDN],
+      [["-0x53aa981b6c9300p-55", 53, 16], ["-0xc1bdceeee0f57p-52",  53, 16], MPC.new([GMP::F(0,45), GMP::F( 4, 57)]), MPC::MPC_RNDZZ],
+      [["-0x6a88995d4dc810p-56", 53, 16], [ "0x1d18f6ead1b445p-53", 53, 16], MPC.new([GMP::F(0,43), GMP::F( 2, 58)]), MPC::MPC_RNDUZ],
+      [[ "0x114a280fb5068bp-53", 53, 16], ["-0xd76aa47848677p-52",  53, 16], MPC.new([GMP::F(0,41), GMP::F(-1, 59)]), MPC::MPC_RNDDZ],
+      [[ "0x1eb9b7097822f5p-53", 53, 16], [ "0x4787c62ac28b0p-52",  53, 16], MPC.new([GMP::F(0,39), GMP::F(-6, 60)]), MPC::MPC_RNDNZ],
+      [["-0x6a88995d4dc810p-56", 53, 16], [ "0xe8c7b7568da23p-52",  53, 16], MPC.new([GMP::F(0,37), GMP::F( 2, 61)]), MPC::MPC_RNDUU],
+      [[ "0x114a280fb5068bp-53", 53, 16], [ "0x1aed548f090cefp-53", 53, 16], MPC.new([GMP::F(0,35), GMP::F( 1, 62)]), MPC::MPC_RNDDU],
+      [[ "0x1eb9b7097822f5p-53", 53, 16], [ "0x11e1f18ab0a2c1p-54", 53, 16], MPC.new([GMP::F(0,33), GMP::F(-6, 63)]), MPC::MPC_RNDNU],
+      [["-0x53aa981b6c9300p-55", 53, 16], [ "0x1837b9dddc1eafp-53", 53, 16], MPC.new([GMP::F(0,31), GMP::F(-4, 64)]), MPC::MPC_RNDZU],
+      [[ "0x114a280fb5068bp-53", 53, 16], [ "0xd76aa47848677p-52",  53, 16], MPC.new([GMP::F(0,29), GMP::F( 1, 65)]), MPC::MPC_RNDDD],
+      [[ "0x1eb9b7097822f5p-53", 53, 16], ["-0x11e1f18ab0a2c1p-54", 53, 16], MPC.new([GMP::F(0,27), GMP::F( 6, 66)]), MPC::MPC_RNDND],
+      [["-0x53aa981b6c9300p-55", 53, 16], [ "0xc1bdceeee0f57p-52",  53, 16], MPC.new([GMP::F(0,25), GMP::F(-4, 67)]), MPC::MPC_RNDZD],
+      [["-0x6a88995d4dc810p-56", 53, 16], ["-0xe8c7b7568da23p-52",  53, 16], MPC.new([GMP::F(0,23), GMP::F(-2, 68)]), MPC::MPC_RNDUD]
+    ]
+    data.each do |expected_real, expected_imag, input, rounding_mode|
+      actual = input.exp(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+
+  it 'should calculate the exponential of input close to zero' do
+      actual = MPC.new([GMP::F("0x1E02AE0D0F6Fp-7213521", 53, 16), GMP::F("0x5D7A2148071Fp-7213522", 53, 16)]).exp(MPC::MPC_RNDNN)
+      actual.real.should eq GMP::F(1)
+      actual.imag.should eq GMP::F("0x5D7A2148071Fp-7213522", 53, 16)
+  end
+end

data/spec/hash_arguments_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe MPC, "methods with optional hash arguments" do
+  before do
+    #@z_sqr = MPC.new([GMP::F("0x10000000020000p+04", 53, 16), GMP::F("0x10000000effff", 53, 16)])
+    #@z = MPC.new([GMP::F("0x400008000180fp-22", 53, 16), GMP::F("0x7ffff0077efcbp-32", 53, 16)])
+    @z_sqr = MPC.new([GMP::F("-0x10000000020000p+04", 53, 16), GMP::F("0x10000000efffefp-04", 53, 16)])
+    @z = MPC.new([GMP::F("0x7ffff0077efcbp-32", 53, 16), GMP::F("0x400008000180fp-22", 53, 16)])
+  end
+
+  it "should allow #sqr to accept :rounding_mode hash argument" do
+    @z.sqr(:rounding_mode => MPC::MPC_RNDZZ).should eq @z_sqr
+    @z.sqr(:rounding => MPC::MPC_RNDZZ).should eq @z_sqr
+    @z.sqr(:round => MPC::MPC_RNDZZ).should eq @z_sqr
+    @z.sqr(:rnd => MPC::MPC_RNDZZ).should eq @z_sqr
+  end
+end

data/spec/log_spec.rb

@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+# All tests adapted from MPC 1.0.1's tests/log.dat
+describe MPC, '#log' do
+  it 'should calculate the logarithm of 1 + 0i' do
+    actual = MPC.new([1, 0]).log
+    actual.real.should eq 0
+    actual.imag.should eq 0
+  end
+
+  it 'should calculate the logarithm of -1 + 0i' do
+    actual = MPC.new([-1, 0]).log
+    actual.real.should eq 0
+    actual.imag.should eq GMP::F("0x3243F6A8885A3p-48", 53, 16)
+
+    actual = MPC.new([GMP::F(-1), -GMP::F(0)]).log
+    actual.real.should eq 0
+    actual.imag.should eq GMP::F("-0x3243F6A8885A3p-48", 53, 16)
+  end
+
+  it 'should calculate the logarithm of x +i*y with either x or y zero and the other non-zero' do
+    data = [
+      [["0xB5535E0FD3FBDp-50", 53, 16], [ 0,  2],                         MPC.new([GMP::F( "0x11", 5, 16),  GMP::F(0, 2)]), MPC::MPC_RNDNN],
+      [["0xB5535E0FD3FBDp-50", 53, 16], [ "0x3243F6A8885A3p-49", 53, 16], MPC.new([GMP::F(0, 2),  GMP::F( "0x11", 5, 16)]), MPC::MPC_RNDNN],
+      [["0x5E38D81812CCBp-49", 53, 16], [ "0x3243F6A8885A3p-48", 53, 16], MPC.new([GMP::F("-0x13", 5, 16),  GMP::F(0, 2)]), MPC::MPC_RNDNN],
+      [["0x5E38D81812CCBp-49", 53, 16], ["-0x3243F6A8885A3p-48", 53, 16], MPC.new([GMP::F("-0x13", 5, 16), -GMP::F(0, 2)]), MPC::MPC_RNDNN],
+      [["0x5E38D81812CCBp-49", 53, 16], ["-0x3243F6A8885A3p-49", 53, 16], MPC.new([GMP::F(0, 2),  GMP::F("-0x13", 5, 16)]), MPC::MPC_RNDNN],
+    ]
+    data.each do |expected_real, expected_imag, input, rounding_mode|
+      actual = input.log(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+
+  ### There are still more tests in log.data, each a result of some bug or other thing
+end

data/spec/mpc_single_function_args_spec.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe "MPC_SINGLE_FUNCTION args" do
+  before do
+    @functions = [
+      :sin,  :cos,  :tan,
+      :sinh, :cosh, :tanh,
+      :asin, :acos, :atan
+    ]
+    @z = MPC.new(0,0)
+  end
+  it "should accept no arguments" do
+    @functions.each do |func|
+      expect { @z.send(func) }.to_not raise_error(ArgumentError)
+    end
+  end
+
+  it "should accept a single rounding mode argument, MPC_RNDNN" do
+    @functions.each do |func|
+      expect { @z.send(func, MPC::MPC_RNDNN) }.to_not raise_error(ArgumentError)
+    end
+  end
+
+  it "should accept a single rounding mode argument, MPC_RNDZD" do
+    @functions.each do |func|
+      expect { @z.send(func, MPC::MPC_RNDZD) }.to_not raise_error(ArgumentError)
+    end
+  end
+
+  it "should accept a single rounding mode argument and a single precision" do
+    @functions.each do |func|
+      expect { @z.send(func, MPC::MPC_RNDZZ, 128) }.to_not raise_error(ArgumentError)
+    end
+  end
+
+  it "should accept a single rounding mode argument and two precisions" do
+    @functions.each do |func|
+      expect { @z.send(func, MPC::MPC_RNDZZ, 128, 256) }.to_not raise_error(ArgumentError)
+    end
+  end
+end

data/spec/neg_spec.rb

@@ -0,0 +1,30 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+# All tests adapted from MPC 1.0.1's tests/neg.dat
+describe MPC, '#@-' do
+  it 'should calculate the negation of a pure real argument' do
+    data = [
+      [["-0x123456789abcdep+52", 53, 16], [ 0,  2], MPC.new([GMP::F( "0x123456789abcdep+52", 53, 16), GMP::F(0, 17)]), MPC::MPC_RNDNN],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0,  3], MPC.new([GMP::F("-0x123456789abcdep+52", 54, 16), GMP::F(0, 16)]), MPC::MPC_RNDZN],
+      [["-0x123456789abcdep+52", 53, 16], [ 0,  4], MPC.new([GMP::F( "0x123456789abcdep+52", 55, 16), GMP::F(0, 15)]), MPC::MPC_RNDUN],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0,  5], MPC.new([GMP::F("-0x123456789abcdep+52", 56, 16), GMP::F(0, 14)]), MPC::MPC_RNDDN],
+      [["-0x123456789abcdep+52", 53, 16], [ 0,  6], MPC.new([GMP::F( "0x123456789abcdep+52", 57, 16), GMP::F(0, 13)]), MPC::MPC_RNDZZ],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0,  7], MPC.new([GMP::F("-0x123456789abcdep+52", 58, 16), GMP::F(0, 12)]), MPC::MPC_RNDUZ],
+      [["-0x123456789abcdep+52", 53, 16], [ 0,  8], MPC.new([GMP::F( "0x123456789abcdep+52", 59, 16), GMP::F(0, 11)]), MPC::MPC_RNDDZ],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0,  9], MPC.new([GMP::F("-0x123456789abcdep+52", 60, 16), GMP::F(0, 10)]), MPC::MPC_RNDNZ],
+      [["-0x123456789abcdep+52", 53, 16], [ 0, 10], MPC.new([GMP::F( "0x123456789abcdep+52", 61, 16), GMP::F(0,  9)]), MPC::MPC_RNDUU],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0, 11], MPC.new([GMP::F("-0x123456789abcdep+52", 62, 16), GMP::F(0,  8)]), MPC::MPC_RNDDU],
+      [["-0x123456789abcdep+52", 53, 16], [ 0, 12], MPC.new([GMP::F( "0x123456789abcdep+52", 63, 16), GMP::F(0,  7)]), MPC::MPC_RNDNU],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0, 13], MPC.new([GMP::F("-0x123456789abcdep+52", 64, 16), GMP::F(0,  6)]), MPC::MPC_RNDZU],
+      [["-0x123456789abcdep+52", 53, 16], [ 0, 14], MPC.new([GMP::F( "0x123456789abcdep+52", 65, 16), GMP::F(0,  5)]), MPC::MPC_RNDDD],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0, 15], MPC.new([GMP::F("-0x123456789abcdep+52", 66, 16), GMP::F(0,  4)]), MPC::MPC_RNDND],
+      [["-0x123456789abcdep+52", 53, 16], [ 0, 16], MPC.new([GMP::F( "0x123456789abcdep+52", 67, 16), GMP::F(0,  3)]), MPC::MPC_RNDZD],
+      [[ "0x123456789abcdep+52", 53, 16], [ 0, 17], MPC.new([GMP::F("-0x123456789abcdep+52", 68, 16), GMP::F(0,  2)]), MPC::MPC_RNDUD]
+    ]
+    data.each do |expected_real, expected_imag, input, rounding_mode|
+      actual = input.neg(rounding_mode)
+      actual.real.should eq GMP::F.new(*expected_real)
+      actual.imag.should eq GMP::F.new(*expected_imag)
+    end
+  end
+end

data/spec/new_spec.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe MPC, '#initialize without precision or rounding args' do
+  before do
+    @z1 = GMP::Z(8)
+    @z2 = GMP::Z(-13)
+    @q1 = GMP::Q(1,3)
+    @q2 = GMP::Q(-2,3)
+    @f1 = GMP::F(1.5)
+    @f2 = GMP::F(-2.5)
+  end
+  it 'should not raise anything when initialized with no args' do
+    expect { MPC.new() }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with 0' do
+    expect { MPC.new(0) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a negative Fixnum' do
+    expect { MPC.new(-32) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a positive Fixnum' do
+    expect { MPC.new(32) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with 0.0' do
+    expect { MPC.new(0.0) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a positive Float' do
+    expect { MPC.new(3.14) }.to_not raise_error
+    expect { MPC.new(1.618) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a positive GMP::Z' do
+    expect { MPC.new(@z1) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a negative GMP::Z' do
+    expect { MPC.new(@z2) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a positive GMP::Q' do
+    expect { MPC.new(@q1) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a negative GMP::Q' do
+    expect { MPC.new(@q2) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a positive GMP::F' do
+    expect { MPC.new(@f1) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with a negative GMP::F' do
+    expect { MPC.new(@f2) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with an Array of 0\'s' do
+    expect { MPC.new([0,0]) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with an Array of Fixnum\'s' do
+    expect { MPC.new([-2**10, 2**11]) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with an Array of Float\'s' do
+    expect { MPC.new([1.4142135623730951, 1.4142135623730951]) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with an Array of GMP::Z\'s' do
+    expect { MPC.new([@z1, @z2]) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with an Array of GMP::Q\'s' do
+    expect { MPC.new([@q1, @q2]) }.to_not raise_error
+  end
+
+  it 'should not raise anything when initialized with an Array of GMP::F\'s' do
+    expect { MPC.new([@f1, @f2]) }.to_not raise_error
+  end
+
+  it 'should raise TypeError when initialized with an Array of mixed types' do
+    expect { MPC.new([0, 0.0]) }.to raise_error(TypeError)
+    expect { MPC.new([0, @z1]) }.to raise_error(TypeError)
+    expect { MPC.new([@f1, 0.0]) }.to raise_error(TypeError)
+    expect { MPC.new([@z1, @f1]) }.to raise_error(TypeError)
+    expect { MPC.new([@q1, 42]) }.to raise_error(TypeError)
+  end
+
+  it 'should initialize default values correctly' do
+    MPC.new(0).should eq MPC.new()
+    MPC.new(0.0).should eq MPC.new()
+  end
+end