gnu_mpc 0.8.2 → 0.9.0

data/spec/atan_spec.rb

@@ -2,7 +2,7 @@ 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
+  it 'calculates 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)])],
@@ -17,12 +17,12 @@ describe MPC, '#atan' do
     ]
     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)
+      expect(actual.real).to eq GMP::F.new(*expected_real)
+      expect(actual.imag).to eq GMP::F.new(*expected_imag)
     end
   end
 
-  it 'should calculate the inverse tangent of a pure imaginary argument' do
+  it 'calculates 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    )])],
@@ -40,32 +40,32 @@ describe MPC, '#atan' do
     ]
     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)
+      expect(actual.real).to eq GMP::F.new(*expected_real)
+      expect(actual.imag).to eq GMP::F.new(*expected_imag)
     end
   end
 
-  it 'should calculate the inverse tangent of a pure imaginary argument, 512 precision' do
+  it 'calculates 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)
+    expect(actual.real).to eq GMP::F.new("0x6487ED5110B4611A62633145C06E0E68948127044533E63A0105DF531D89CD9128A5043CC71A026EF7CA8CD9E69D218D98158536F92F8A1BA7F09AB6B6A8E123p-510", 512, 16)
+    expect(actual.imag).to eq GMP::F.new("0x5D137113B914461DA3202D77346EE4980DA5FD0BAD68F5A7928DCA9F632750D9BFFA00654C523929F15DED554EC6BC476DB2C46FA433E569227085E0BDEA86FFp-509", 512, 16)
   end
 
-  it 'should calculate the inverse tangent of a pure imaginary argument, 12 precision' do
+  it 'calculates 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)
+    expect(actual.real).to eq GMP::F.new("0xC91p-11", 12, 16)
+    expect(actual.imag).to eq GMP::F.new("0x6F1p-50", 12, 16)
   end
 
-  it 'should calculate the inverse tangent of a general inputs' do
+  it 'calculates 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],
@@ -76,34 +76,34 @@ describe MPC, '#atan' do
     ]
     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)
+      expect(actual.real).to eq GMP::F.new(*expected_real)
+      expect(actual.imag).to eq GMP::F.new(*expected_imag)
     end
   end
 
-  it 'should calculate the inverse tangent of a general inputs, 156 precision' do
+  it 'calculates 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)
+    expect(actual.real).to eq GMP::F.new("-0xC90FDAA22167B20DB08A0C3B1FF415CABE49624p-155", 156, 16)
+    expect(actual.imag).to eq GMP::F.new("0xEA84E971BD52E49CCEE036E303D5ECB2D9D9B9Ap-222", 156, 16)
   end
 
-  it 'should calculate the inverse tangent of a general inputs, 2 precision' do
+  it 'calculates 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)
+    expect(actual.real).to eq GMP::F.new( 0.75, 2, 16)
+    expect(actual.imag).to 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)
+    expect(actual.real).to eq GMP::F.new( 0.75, 2, 16)
+    expect(actual.imag).to eq GMP::F.new( 3,    2, 16)
   end
 
-  it 'should calculate the inverse tangent: "improve test coverage"' do
+  it 'calculates 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)
+    expect(actual.real).to eq GMP::F.new("-0x1.921fb54442d184", 57, 16)
+    expect(actual.imag).to eq GMP::F.new("-0x8.a7e33db93ecf18@-34", 57, 16)
   end
 end

data/spec/fma_spec.rb

@@ -0,0 +1,20 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe MPC, "#fma" do
+  before do
+    @a = MPC.new([2, 0])
+    @b = MPC.new([1, 2])
+    @c = MPC.new([2, 2])
+  end
+
+  it "returns the product of an MPC and the first argument, and summed with the second argument" do
+    expect(@a.fma(@b, @c)).to eq(MPC.new([4, 6]))
+  end
+
+  it "accepts hash options" do
+    result = @a.fma(@b, @c, prec: 32)
+    expect(result).to eq(MPC.new([4, 6]))
+    expect(result.real.prec).to eq 32
+    expect(result.imag.prec).to eq 32
+  end
+end

data/spec/imag_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe MPC, "#imag" do
+  it "returns the imaginary part of an MPC generated with a Fixnum" do
+    expect(MPC.new(0).imag).to eq GMP::F(0)
+    expect(MPC.new(1).imag).to eq GMP::F(0)
+    expect(MPC.new([0, 1]).imag).to eq GMP::F(1)
+  end
+
+  it "returns the imaginary part of an MPC generated with a GMP::Z" do
+    expect(MPC.new(GMP::Z(0)).imag).to eq GMP::F(0)
+    expect(MPC.new(GMP::Z(1)).imag).to eq GMP::F(0)
+    expect(MPC.new([GMP::Z(7), GMP::Z(2**64)]).imag).to eq GMP::F(2**64)
+    expect(MPC.new([GMP::Z(0), GMP::Z(1)]).imag).to eq GMP::F(1)
+  end
+
+  it "returns the imaginary part an MPC generated with a Float" do
+    expect(MPC.new(0.0).imag).to eq GMP::F(0)
+    expect(MPC.new([0.0, 1.0]).imag).to eq GMP::F(1)
+    expect(MPC.new([1.0, 1.0]).imag).to eq GMP::F(1)
+    expect(MPC.new([2*Math::PI, Math::PI]).imag).to eq GMP::F(Math::PI)
+  end
+end

data/spec/log10_spec.rb

@@ -1,26 +1,34 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 # All tests adapted from MPC 1.0.1's tests/log10.dat
-describe MPC, '#log' do
-  it 'should calculate the base 10 logarithm of +1 +- i*0' do
+describe MPC, '#log10' do
+  it 'calculates the base 10 logarithm of +1 +- i*0' do
+    pending("log10 introduced in MPC 1.0.0") if MPC::MPC_VERSION[0] == "0"
+
     actual = MPC.new([1, 0], 2).log10
-    actual.real.should eq 0
-    actual.imag.should eq 0
+    expect(actual.real).to eq 0
+    expect(actual.imag).to eq 0
   end
 
-  it 'should calculate the base 10 logarithm of 10 +- i*0' do
+  it 'calculates the base 10 logarithm of 10 +- i*0' do
+    pending("log10 introduced in MPC 1.0.0") if MPC::MPC_VERSION[0] == "0"
+
     actual = MPC.new([GMP::F(10, 4), GMP::F(0, 2)]).log10
-    actual.real.should eq 1
-    actual.imag.should eq 0
+    expect(actual.real).to eq 1
+    expect(actual.imag).to eq 0
   end
 
-  it 'should calculate the base 10 logarithm of 100 +- i*0' do
+  it 'calculates the base 10 logarithm of 100 +- i*0' do
+    pending("log10 introduced in MPC 1.0.0") if MPC::MPC_VERSION[0] == "0"
+
     actual = MPC.new([GMP::F(100, 5), GMP::F(0, 2)]).log10
-    actual.real.should eq 2
-    actual.imag.should eq 0
+    expect(actual.real).to eq 2
+    expect(actual.imag).to eq 0
   end
 
-  it 'should calculate the base 10 logarithm of x +i*y with either x or y zero and the other non-zero' do
+  it 'calculates the base 10 logarithm of x +i*y with either x or y zero and the other non-zero' do
+    pending("log10 introduced in MPC 1.0.0") if MPC::MPC_VERSION[0] == "0"
+
     data = [
       [["0x13afeb354b7d97p-52", 53, 16], [ 0,  2],                          MPC.new([GMP::F( "0x11", 5, 16),  GMP::F(0, 2)]), MPC::MPC_RNDNN],
       [["0x13afeb354b7d97p-52", 53, 16], [ "0x15d47c4cb2fba1p-53", 53, 16], MPC.new([GMP::F(0, 2),  GMP::F( "0x11", 5, 16)]), MPC::MPC_RNDNN],
@@ -30,8 +38,8 @@ describe MPC, '#log' do
     ]
     data.each do |expected_real, expected_imag, input, rounding_mode|
       actual = input.log10(rounding_mode)
-      actual.real.should eq GMP::F.new(*expected_real)
-      actual.imag.should eq GMP::F.new(*expected_imag)
+      expect(actual.real).to eq GMP::F.new(*expected_real)
+      expect(actual.imag).to eq GMP::F.new(*expected_imag)
     end
   end
 

data/spec/mpc_single_function_args_spec.rb

@@ -7,35 +7,35 @@ describe "MPC_SINGLE_FUNCTION args" do
       :sinh, :cosh, :tanh,
       :asin, :acos, :atan
     ]
-    @z = MPC.new(0,0)
+    @z = MPC.new(0)
   end
   it "should accept no arguments" do
     @functions.each do |func|
-      expect { @z.send(func) }.to_not raise_error(ArgumentError)
+      expect { @z.send(func) }.to_not raise_error
     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)
+      expect { @z.send(func, MPC::MPC_RNDNN) }.to_not raise_error
     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)
+      expect { @z.send(func, MPC::MPC_RNDZD) }.to_not raise_error
     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)
+      expect { @z.send(func, MPC::MPC_RNDZZ, 128) }.to_not raise_error
     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)
+      expect { @z.send(func, MPC::MPC_RNDZZ, 128, 256) }.to_not raise_error
     end
   end
 end

data/spec/new_spec.rb

@@ -8,81 +8,95 @@ describe MPC, '#initialize without precision or rounding args' do
     @q2 = GMP::Q(-2,3)
     @f1 = GMP::F(1.5)
     @f2 = GMP::F(-2.5)
+    @big_2_64 = 2**64
+    @big_2_65 = 2**65
+    @z_2_64 = GMP::Z(2**64)
+    @z_2_65 = GMP::Z(2**65)
   end
-  it 'should not raise anything when initialized with no args' do
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it "can be instantiated from a Bignum" do
+    expect { MPC.new(@big_2_64) }.to_not raise_error
+    expect(MPC.new(@big_2_64)).to eq(MPC.new(@z_2_64))
+  end
+
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it "can be instantiated from two Bignums" do
+    expect { MPC.new([@big_2_64, @big_2_65]) }.to_not raise_error
+    expect(MPC.new([@big_2_64, @big_2_65])).to eq(MPC.new([@z_2_64, @z_2_65]))
+  end
+
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'does 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
+  it 'raises 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)
@@ -90,8 +104,25 @@ describe MPC, '#initialize without precision or rounding args' do
     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()
+  it 'initializes default values correctly' do
+    expect(MPC.new(0)).to eq MPC.new()
+    expect(MPC.new(0.0)).to eq MPC.new()
+  end
+
+  it 'raises when the precision is out-of-bounds' do
+    expect { MPC.new(0, -1) }.to raise_error(RangeError)
+    expect { MPC.new(0, 0) }.to raise_error(RangeError)
+    expect { MPC.new(0, 1) }.to raise_error(RangeError)
+  end
+end
+
+describe MPC, '#initialize with precision arguments' do
+  it "accepts a shared precision" do
+    expect(MPC.new(7, 32).prec).to eq(32)
+  end
+
+  it "accepts individual precisions" do
+    expect(MPC.new(7, 32, 64).prec).to eq(0)
+    expect(MPC.new(7, 32, 64).prec2).to eq([32, 64])
   end
 end

data/spec/pow_spec.rb

@@ -0,0 +1,79 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe MPC, '#pow' do
+  before do
+    @w = MPC.new([0, 1])
+  end
+
+  it 'calculates the value of a complex number raised to a Fixnum power' do
+    w = @w.pow 2
+
+    expect(w.real).to eq -1
+    expect(w.imag).to eq 0
+
+    w = @w.pow 3
+
+    expect(w.real).to eq 0
+    expect(w.imag).to eq -1
+  end
+
+  it 'calculates the value of a complex number raised to a GMP::Z power' do
+    w = @w.pow GMP::Z(4)
+
+    expect(w.real).to eq 1
+    expect(w.imag).to eq 0
+  end
+
+  it 'calculates the value of a complaex number raised to a Float power' do
+    w = @w.pow 0.5
+
+    expect(w.real).to eq GMP::F(0.5).sqrt
+    expect(w.imag).to eq GMP::F(0.5).sqrt
+  end
+
+  it 'calculates the value of a complaex number raised to a GMP::F power' do
+    w = @w.pow GMP::F(0.5)
+
+    expect(w.real).to eq GMP::F(0.5).sqrt
+    expect(w.imag).to eq GMP::F(0.5).sqrt
+  end
+end
+
+describe MPC, '#**' do
+  before do
+    @w = MPC.new([0, 1])
+  end
+
+  it 'calculates the value of a complex number raised to a Fixnum power' do
+    w = @w ** 2
+
+    expect(w.real).to eq -1
+    expect(w.imag).to eq 0
+
+    w = @w ** 3
+
+    expect(w.real).to eq 0
+    expect(w.imag).to eq -1
+  end
+
+  it 'calculates the value of a complex number raised to a GMP::Z power' do
+    w = @w ** GMP::Z(4)
+
+    expect(w.real).to eq 1
+    expect(w.imag).to eq 0
+  end
+
+  it 'calculates the value of a complaex number raised to a Float power' do
+    w = @w ** 0.5
+
+    expect(w.real).to eq GMP::F(0.5).sqrt
+    expect(w.imag).to eq GMP::F(0.5).sqrt
+  end
+
+  it 'calculates the value of a complaex number raised to a GMP::F power' do
+    w = @w ** GMP::F(0.5)
+
+    expect(w.real).to eq GMP::F(0.5).sqrt
+    expect(w.imag).to eq GMP::F(0.5).sqrt
+  end
+end