gnu_mpc 0.8.2 → 0.9.0

data/ext/mpcrnd.c

@@ -44,9 +44,9 @@ VALUE r_mpcrndsg_new(int argc, VALUE *argv, VALUE klass)
 VALUE r_mpcrnd_initialize(int argc, VALUE *argv, VALUE self)
 {
   VALUE mode, name, ieee754;
-  mode = argv[0];
-  (void)argc;
   char name_val[12];
+  (void)argc;
+  mode = argv[0];
 
   switch (FIX2INT(mode) % 16) {
   case 0:
@@ -162,8 +162,8 @@ mpc_rnd_t r_mpc_get_rounding_mode(VALUE rnd)
 
 void init_mpcrnd()
 {
-  cMPC = rb_define_class ("MPC", rb_cNumeric);
   ID new_id = rb_intern ("new");
+  cMPC = rb_define_class ("MPC", rb_cNumeric);
 
   cMPC_Rnd = rb_define_class_under (cMPC, "Rnd", rb_cObject);
 

data/ext/ruby_gmp.h

@@ -58,10 +58,10 @@ typedef __gmp_randstate_struct MP_RANDSTATE;
 }*/
 #define mpz_temp_alloc(var) { var=malloc(sizeof(MP_INT)); }
 #define mpz_temp_init(var) { mpz_temp_alloc(var); mpz_init(var); }
-#define mpz_temp_from_bignum(var,var_bignum) {                 \
-  mpz_temp_alloc(var);                                         \
-  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32));  \
-  mpz_init_set_str (var, StringValuePtr (tmp), 32);             \
+#define mpz_temp_from_bignum(var,var_bignum) {                               \
+  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX (32));  \
+  mpz_temp_alloc(var);                                                       \
+  mpz_init_set_str (var, StringValuePtr (tmp), 32);                          \
 }
 #define mpz_temp_free(var) { mpz_clear(var); free(var); }
 #define mpf_temp_alloc(var) { var=malloc(sizeof(MP_FLOAT)); }

data/ext/ruby_mpc.h

@@ -39,6 +39,7 @@ typedef __mpc_struct MP_COMPLEX;
 
 /* EXPECTED_Cxxx macros */
 #define EXPECTED_FXC "Expected GMP::F, Fixnum, or MPC"
+#define EXPECTED_XBZFC "Expected Fixnum, Bignum, GMP::Z, Float, GMP::F, or MPC"
 
 // MPC Rounding Modes
 #define mpcrnd_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, int, c_var); }
@@ -59,5 +60,6 @@ extern mpc_rnd_t r_get_mpc_rounding_mode(VALUE rnd);
 extern mpc_rnd_t r_get_default_mpc_rounding_mode();
 extern mpc_rnd_t r_mpc_get_rounding_mode(VALUE rnd);
 extern void init_mpcrnd();
+extern void init_gmprandstate_mpc();
 
 #endif /* _RUBY_MPC_H_ */

data/manual.md

@@ -208,19 +208,19 @@ for optional arguments, after any required arguments. For example, since
 be supplied like so:
 
     MPC.new([1,1]).pow(2, {})
-    MPC.new([0.5, 0.5]).sin({})
+    MPC.new([1,1]).sin({})
 
 Here are the keys typically accepted by an `MPC` instance method.
 
 `:rnd`, `:round`, `:rounding`, `:rounding_mode`
-:   Rounding mode for the operation
+:   rounding mode for the operation
 `:prec`, `:precision`
-:   Precision used when initializing the return value; This precision will be
+:   precision used when initializing the return value; This precision will be
     used for both the real and imaginary parts of the returned complex value.
 `:real_prec`, `:real_precision`
-:   Precision used for the real part of the return value
+:   precision used for the real part of the return value
 `:imag_prec`, `:imag_precision`
-:   Precision used for the imaginary part of the return value
+:   precision used for the imaginary part of the return value
 
 ### Precision of Returned Values
 
@@ -241,7 +241,8 @@ of three ways:
 
 * The user can also specify the precision of the real part, and the imaginary
   part, individually, using the options hash as well. The `:real_prec`,
-  `:real_precision`, `:imag_prec`, and `:imag_precision` keys can be used:
+  (or `:real_precision`) and `:imag_prec` (or `:imag_precision`) keys can be
+  used:
 
         MPC.new(72).sin(:real_prec => 17, :imag_prec => 53)
   The broad `:prec` and `:precision` values are parsed before the real- and
@@ -356,7 +357,8 @@ MPC.new(GMP::Z.new(31))  #=> 31 (GMP Integer)
 \begin{tabular}{p{\methwidth} l r p{\returnwidth}}
 \toprule
 \textbf{real} & & MPC\#real() & $\rightarrow$ \textit{GMP::F} \\
-& & MPC\#real(\textit{rounding\_mode} = MPC::MPC\_RNDNN) & $\rightarrow$ \textit{GMP::F} \\
+& & MPC\#real(\textit{rounding\_mode} = MPC::MPC\_RNDNN, & \\
+& & \textit{precision} = \textit{mpfr\_default\_precision}) & $\rightarrow$ \textit{GMP::F} \\
 \cmidrule(r){2-4}
 & \multicolumn{3}{p{\defnwidth}}{
   Return the real part of the receiver, rounded according to
@@ -365,7 +367,8 @@ MPC.new(GMP::Z.new(31))  #=> 31 (GMP Integer)
 
 \toprule
 \textbf{imag} & & MPC\#imag() & $\rightarrow$ \textit{GMP::F} \\
-& & MPC\#imag(\textit{rounding\_mode} = MPC::MPC\_RNDNN) & $\rightarrow$ \textit{GMP::F} \\
+& & MPC\#imag(\textit{rounding\_mode} = MPC::MPC\_RNDNN, & \\
+& & \textit{precision} = \textit{mpfr\_default\_precision}) & $\rightarrow$ \textit{GMP::F} \\
 \cmidrule(r){2-4}
 & \multicolumn{3}{p{\defnwidth}}{
   Return the imaginary part of the receiver, rounded according to
@@ -373,10 +376,19 @@ MPC.new(GMP::Z.new(31))  #=> 31 (GMP Integer)
 } \\
 
 \toprule
-\textbf{proj} & & MPC\#proj() & $\rightarrow$ \textit{GMP::F} \\
-& & MPC\#proj(\textit{rounding\_mode} = MPC::MPC\_RNDNN, & \\
+\textbf{arg} & & MPC\#arg() & $\rightarrow$ \textit{GMP::F} \\
+& & MPC\#arg(\textit{rounding\_mode} = MPC::MPC\_RNDNN, & \\
 & & \textit{precision} = \textit{mpfr\_default\_precision}) & $\rightarrow$ \textit{GMP::F} \\
 \cmidrule(r){2-4}
+& \multicolumn{3}{p{\defnwidth}}{
+  Return the argument of the receiver, rounded according to $rounding\_mode$.
+} \\
+
+\toprule
+\textbf{proj} & & MPC\#proj() & $\rightarrow$ \textit{MPC} \\
+& & MPC\#proj(\textit{rounding\_mode} = MPC::MPC\_RNDNN, & \\
+& & \textit{precision} = \textit{mpfr\_default\_precision}) & $\rightarrow$ \textit{MPC} \\
+\cmidrule(r){2-4}
 & \multicolumn{3}{p{\defnwidth}}{
   Return the projection of the receiver onto the Riemann sphere, rounded according to
   $rounding\_mode$.
@@ -389,7 +401,7 @@ MPC.new(GMP::Z.new(31))  #=> 31 (GMP Integer)
     <th>real</th><th>`MPC#real()` $\rightarrow$ _GMP::F_
   </tr>
   <tr class="last-header">
-    <th></th>   <th><code>MPC#real(_rounding_mode_ = MPC::MPC_RNDNN)</code> $\rightarrow$ _GMP::F_
+    <th></th>   <th><code>MPC#real(_rounding_mode_ = MPC::MPC_RNDNN, _precision_ = _mpfr_default_)</code> $\rightarrow$ _GMP::F_
 </th>
   </tr>
   <tr>
@@ -403,7 +415,7 @@ Return the real part of the receiver, rounded according to $rounding\_mode$.
     <th>imag</th><th>`MPC#imag()` $\rightarrow$ _GMP::F_
   </tr>
   <tr class="last-header">
-    <th></th>   <th><code>MPC#imag(_rounding_mode_ = MPC::MPC_RNDNN)</code> $\rightarrow$ _GMP::F_
+    <th></th>   <th><code>MPC#imag(_rounding_mode_ = MPC::MPC_RNDNN, _precision_ = _mpfr_default_)</code> $\rightarrow$ _GMP::F_
 </th>
   </tr>
   <tr>
@@ -414,10 +426,24 @@ Return the imaginary part of the receiver, rounded according to $rounding\_mode$
   </tr>
 
   <tr class="new-method">
-    <th>proj</th><th>`MPC#proj()` $\rightarrow$ _GMP::F_
+    <th>arg</th><th>`MPC#arg()` $\rightarrow$ _GMP::F_
+  </tr>
+  <tr class="last-header">
+    <th></th>   <th><code>MPC#arg(_rounding_mode_ = MPC::MPC_RNDNN, _precision_ = _mpfr_default_)</code> $\rightarrow$ _GMP::F_
+</th>
+  </tr>
+  <tr>
+    <td></td>
+    <td>
+Return the argument of the receiver, rounded according to $rounding\_mode$.
+    </td>
+  </tr>
+
+  <tr class="new-method">
+    <th>proj</th><th>`MPC#proj()` $\rightarrow$ _MPC_
   </tr>
   <tr>
-    <th></th>   <th><code>MPC#proj(_rounding_mode_ = MPC::MPC_RNDNN, _precision_ = _mpfr_default_)</code> $\rightarrow$ _GMP::F_
+    <th></th>   <th><code>MPC#proj(_rounding_mode_ = MPC::MPC_RNDNN, _precision_ = _mpfr_default_)</code> $\rightarrow$ _MPC_
 </th>
   </tr>
   <tr class="last-header">

data/spec/acos_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 
 # All tests adapted from MPC 1.0.1's tests/acos.dat
 describe MPC, '#acos' do
-  it 'should calculate the inverse cosine of a pure real argument' do
+  it 'calculates the inverse cosine of a pure real argument' do
     data = [
       [[ "0x1921FB54442D18p-51", 53, 16], [ "0x13D2B7539DBA4Cp-51", 53, 16], MPC.new([GMP::F(-6  ), -GMP::F(0)])],
       [[ "0x1921FB54442D18p-51", 53, 16], ["-0x13D2B7539DBA4Cp-51", 53, 16], MPC.new([GMP::F(-6  ),  GMP::F(0)])],
@@ -23,12 +23,12 @@ describe MPC, '#acos' do
     ]
     data.each do |expected_real, expected_imag, input|
       actual = input.acos
-      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 cosine of a pure imaginary argument' do
+  it 'calculates the inverse cosine of a pure imaginary argument' do
     data = [
       [["0x1921FB54442D18p-52", 53, 16], [ "0x1D185B507EDC0Ep-52", 53, 16], MPC.new([-GMP::F(0), GMP::F(-3   )])],
       [["0x1921FB54442D18p-52", 53, 16], [ "0x1D185B507EDC0Ep-52", 53, 16], MPC.new([ GMP::F(0), GMP::F(-3   )])],
@@ -41,26 +41,26 @@ describe MPC, '#acos' do
     ]
     data.each do |expected_real, expected_imag, input|
       actual = input.acos
-      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 cosine with other precisions' do
+  it 'calculates the inverse cosine with other precisions' do
     actual = MPC.new([GMP::F.new(2), GMP::F.new(1)]).acos(MPC::MPC_RNDNZ, 2)
-    actual.real.should eq GMP::F.new( 0.5, 2)
-    actual.imag.should eq GMP::F.new(-1,   2)
+    expect(actual.real).to eq GMP::F.new( 0.5, 2)
+    expect(actual.imag).to eq GMP::F.new(-1,   2)
   end
 
-  it 'should calculate the inverse cosine with other precisions' do
+  it 'calculates the inverse cosine with other precisions' do
     actual = MPC.new([GMP::F.new(8.5), GMP::F.new(-71)]).acos(MPC::MPC_RNDNU, 9)
-    actual.real.should eq GMP::F.new("0x5Dp-6", 9, 16)
-    actual.imag.should eq GMP::F.new("0x9Fp-5", 9, 16)
+    expect(actual.real).to eq GMP::F.new("0x5Dp-6", 9, 16)
+    expect(actual.imag).to eq GMP::F.new("0x9Fp-5", 9, 16)
   end
 
-  it 'should calculate the inverse cosine with other precisions' do
+  it 'calculates the inverse cosine with other precisions' do
     actual = MPC.new([GMP::F.new("0x3243F6A8885A3p-48", 53, 16), GMP::F.new("0x162E42FEFA39EFp-53", 53, 16)]).acos
-    actual.real.should eq GMP::F.new("0x74C141310E695p-53", 53, 16)
-    actual.imag.should eq GMP::F.new("-0x1D6D2CFA9F3F11p-52", 53, 16)
+    expect(actual.real).to eq GMP::F.new("0x74C141310E695p-53", 53, 16)
+    expect(actual.imag).to eq GMP::F.new("-0x1D6D2CFA9F3F11p-52", 53, 16)
   end
 end

data/spec/add_args_spec.rb

@@ -1,51 +1,51 @@
 require File.join(File.dirname(__FILE__), 'spec_helper')
 
 describe MPC, '#add' do
-  it 'should calculate the sum of an MPC and a Fixnum' do
+  it 'calculate the sum of an MPC and a Fixnum' do
     op1 = MPC.new([7, 16])
     actual = op1.add(0)
-    actual.real.should eq 7
-    actual.imag.should eq 16
+    expect(actual.real).to eq 7
+    expect(actual.imag).to eq 16
 
     actual = op1.add(6)
-    actual.real.should eq 13
-    actual.imag.should eq 16
+    expect(actual.real).to eq 13
+    expect(actual.imag).to eq 16
 
     actual = op1.add(-1000)
-    actual.real.should eq -993
-    actual.imag.should eq 16
+    expect(actual.real).to eq -993
+    expect(actual.imag).to eq 16
 
     op1 = MPC.new([GMP::F(3.1), GMP::F(16)])
     actual = op1.add(3)
-    actual.real.should eq GMP::F(6.1)
-    actual.imag.should eq 16
+    expect(actual.real).to eq GMP::F(6.1)
+    expect(actual.imag).to eq 16
   end
 
-  it 'should calculate the sum of an MPC and a GMP::Z' do
+  it 'calculates the sum of an MPC and a GMP::Z' do
     op1 = MPC.new([7, 16])
     actual = op1.add(GMP::Z(0))
-    actual.real.should eq 7
-    actual.imag.should eq 16
+    expect(actual.real).to eq 7
+    expect(actual.imag).to eq 16
 
     actual = op1.add(GMP::Z(-1000))
-    actual.real.should eq -993
-    actual.imag.should eq 16
+    expect(actual.real).to eq -993
+    expect(actual.imag).to eq 16
 
     op1 = MPC.new([GMP::F(3.1), GMP::F(16)])
     actual = op1.add(GMP::Z(3))
-    actual.real.should eq GMP::F(6.1)
-    actual.imag.should eq 16
+    expect(actual.real).to eq GMP::F(6.1)
+    expect(actual.imag).to eq 16
   end
 
-  it 'should calculate the sum of an MPC and a Bignum' do
+  it 'calculates the sum of an MPC and a Bignum' do
     op1 = MPC.new([7, 16])
     actual = op1.add(2**65)  # 36893488147419103232
-    actual.real.should eq 36893488147419103239
-    actual.imag.should eq 16
+    expect(actual.real).to eq 36893488147419103239
+    expect(actual.imag).to eq 16
 
     op1 = MPC.new([GMP::F(3.1), GMP::F(16)])
     actual = op1.add(2**65)  # 36893488147419103232
-    actual.real.should eq GMP::F("36893488147419103235.1")
-    actual.imag.should eq 16
+    expect(actual.real).to eq GMP::F("36893488147419103235.1")
+    expect(actual.imag).to eq 16
   end
 end

data/spec/add_fr_spec.rb

@@ -2,53 +2,53 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 
 # All tests adapted from MPC 1.0.1's tests/add.dat
 describe MPC, '#add' do
-  it 'should calculate the sum of two real MPCs' do
+  it 'calculates the sum of two real MPCs' do
     op1 = MPC.new([1, 0])
     op2_106 = GMP::F("0x10000000000001p-106", 53, 16)
     actual = op1.add(op2_106, MPC::MPC_RNDNN)
-    actual.real.should eq GMP::F("0x10000000000000p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000000p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
 
     op2_105 = GMP::F("0x10000000000001p-105", 53, 16)
     actual = op1.add(op2_105, MPC::MPC_RNDNN)
-    actual.real.should eq GMP::F("0x10000000000001p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000001p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
 
     op2_104 = GMP::F("0x10000000000001p-104", 53, 16)
     actual = op1.add(op2_104, MPC::MPC_RNDNN)
-    actual.real.should eq GMP::F("0x10000000000001p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000001p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
 
     actual = op1.add(op2_105, MPC::MPC_RNDZZ)
-    actual.real.should eq GMP::F("0x10000000000000p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000000p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
 
     actual = op1.add(op2_105, MPC::MPC_RNDUU)
-    actual.real.should eq GMP::F("0x10000000000001p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000001p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
 
     actual = op1.add(op2_105, MPC::MPC_RNDDD)
-    actual.real.should eq GMP::F("0x10000000000000p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000000p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
   end
 
-  it 'should calculate the sum of an imaginary argument with a complex one.' do
+  it 'calculates the sum of an imaginary argument with a complex one.' do
     op1 = MPC.new([0, 1])
     op2 = GMP::F(1)
     actual = op1.add(op2, MPC::MPC_RNDNN)
-    actual.real.should eq GMP::F(1)
-    actual.imag.should eq GMP::F(1)
+    expect(actual.real).to eq GMP::F(1)
+    expect(actual.imag).to eq GMP::F(1)
 
     actual = op1.add(op2, MPC::MPC_RNDZZ)
-    actual.real.should eq GMP::F(1)
-    actual.imag.should eq GMP::F(1)
+    expect(actual.real).to eq GMP::F(1)
+    expect(actual.imag).to eq GMP::F(1)
 
     actual = op1.add(op2, MPC::MPC_RNDUU)
-    actual.real.should eq GMP::F(1)
-    actual.imag.should eq GMP::F(1)
+    expect(actual.real).to eq GMP::F(1)
+    expect(actual.imag).to eq GMP::F(1)
 
     actual = op1.add(op2, MPC::MPC_RNDDD)
-    actual.real.should eq GMP::F(1)
-    actual.imag.should eq GMP::F(1)
+    expect(actual.real).to eq GMP::F(1)
+    expect(actual.imag).to eq GMP::F(1)
   end
 end

data/spec/add_spec.rb

@@ -2,31 +2,31 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 
 # All tests adapted from MPC 1.0.1's tests/add.dat
 describe MPC, '#add' do
-  it 'should calculate the sum of two real MPCs' do
+  it 'calculates the sum of two real MPCs' do
     op1 = MPC.new([1, 0])
     op2 = MPC.new([GMP::F("0x10000000000001p-105", 53, 16), GMP::F(0)])
     actual = op1.add(op2, MPC::MPC_RNDNN)
-    actual.real.should eq GMP::F("0x10000000000001p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000001p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
 
     actual = op1.add(op2, MPC::MPC_RNDZZ)
-    actual.real.should eq GMP::F("0x10000000000000p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000000p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
 
     actual = op1.add(op2, MPC::MPC_RNDUU)
-    actual.real.should eq GMP::F("0x10000000000001p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000001p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
 
     actual = op1.add(op2, MPC::MPC_RNDDD)
-    actual.real.should eq GMP::F("0x10000000000000p-52", 53, 16)
-    actual.imag.should eq GMP::F(0)
+    expect(actual.real).to eq GMP::F("0x10000000000000p-52", 53, 16)
+    expect(actual.imag).to eq GMP::F(0)
   end
 
-  it 'should calculate the sum of two real MPCs' do
+  it 'calculates the sum of two real MPCs' do
     op2 = MPC.new([GMP::F(0), GMP::F("0x10000000000001p-105", 53, 16)])
     op1 = MPC.new([0, 1])
     actual = op1.add(op2, MPC::MPC_RNDNN)
-    actual.real.should eq GMP::F(0)
-    actual.imag.should eq GMP::F("0x10000000000001p-52", 53, 16)
+    expect(actual.real).to eq GMP::F(0)
+    expect(actual.imag).to eq GMP::F("0x10000000000001p-52", 53, 16)
   end
 end

data/spec/arg_spec.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe MPC, "#arg" do
+  it "returns the argument of an MPC generated with a Fixnum" do
+    expect(MPC.new(0).arg).to eq GMP::F(0)
+    expect(MPC.new(1).arg).to eq GMP::F(0)
+    expect(MPC.new([0, 1]).arg).to eq((2*Math::PI) / 4)
+    expect(MPC.new([1, 1]).arg).to eq((2*Math::PI) / 8)
+  end
+
+  it "returns the argument an MPC generated with a Float" do
+    expect(MPC.new([1.0, Math.sqrt(3)]).arg).to eq((2*Math::PI) / 6)
+  end
+end

data/spec/asin_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(__FILE__), 'spec_helper')
 
 # All tests adapted from MPC 1.0.1's tests/asin.dat
 describe MPC, '#sin' do
-  it 'should calculate the inverse sine of a pure real argument' do
+  it 'calculates the inverse sine of a pure real argument' do
     data = [
       [["-0x1921FB54442D18p-52", 53, 16], ["-0x1ECC2CAEC5160Ap-53", 53, 16], MPC.new([GMP::F(-1.5), -GMP::F(0)])],
       [["-0x1921FB54442D18p-52", 53, 16], [ "0x1ECC2CAEC5160Ap-53", 53, 16], MPC.new([GMP::F(-1.5),  GMP::F(0)])],
@@ -19,12 +19,12 @@ describe MPC, '#sin' do
     ]
     data.each do |expected_real, expected_imag, input|
       actual = input.asin
-      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 sine of a pure imaginary argument' do
+  it 'calculates the inverse sine of a pure imaginary argument' do
     data = [
       [[-GMP::F(0)], ["-0x131DC0090B63D8p-52", 53, 16], MPC.new([-GMP::F(0), GMP::F(-1.5)])],
       [[ GMP::F(0)], ["-0x131DC0090B63D8p-52", 53, 16], MPC.new([ GMP::F(0), GMP::F(-1.5)])],
@@ -41,26 +41,26 @@ describe MPC, '#sin' do
     ]
     data.each do |expected_real, expected_imag, input|
       actual = input.asin
-      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 sine of ieee-754 double precision numbers' do
     actual = MPC.new([GMP::F.new(17), GMP::F.new(42)]).asin(MPC::MPC_RNDNN)
-    actual.real.should eq GMP::F.new("0x189BF9EC7FCD5Bp-54", 53, 16)
-    actual.imag.should eq GMP::F.new("0x1206ECFA94614Bp-50", 53, 16)
+    expect(actual.real).to eq GMP::F.new("0x189BF9EC7FCD5Bp-54", 53, 16)
+    expect(actual.imag).to eq GMP::F.new("0x1206ECFA94614Bp-50", 53, 16)
   end
 
   it 'should calculate the inverse sine with other precisions' do
     actual = MPC.new([GMP::F.new(96), GMP::F.new("0x1p-8", 2, 16)]).asin(MPC::MPC_RNDNN, 2)
-    actual.real.should eq GMP::F.new(1.5, 2)
-    actual.imag.should eq GMP::F.new(6,   2)
+    expect(actual.real).to eq GMP::F.new(1.5, 2)
+    expect(actual.imag).to eq GMP::F.new(6,   2)
   end
 
   it 'should calculate the inverse sine with other precisions' do
     actual = MPC.new([GMP::F.new(96), GMP::F.new("0x1p-8", 2, 16)]).asin(MPC::MPC_RNDNN, 8)
-    actual.real.should eq GMP::F.new("0xC9p-7", 8, 16)
-    actual.imag.should eq GMP::F.new("0x15p-2", 8, 16)
+    expect(actual.real).to eq GMP::F.new("0xC9p-7", 8, 16)
+    expect(actual.imag).to eq GMP::F.new("0x15p-2", 8, 16)
   end
 end