gnu_mpc 0.8.0 → 0.8.1

data/CHANGELOG

@@ -0,0 +1,5 @@
+* v 0.8.1
+  * Added MPC#/, MPC#div
+  * Added MPC#log10
+* v 0.8.0
+  * Most things

data/ext/mpc.c

@@ -850,6 +850,93 @@ VALUE r_mpc_mul_do_the_work(VALUE self_val, VALUE arg_val, mpc_rnd_t rnd_mode, m
   return res_val;
 }
 
+VALUE r_mpc_div_do_the_work(VALUE self_val, VALUE arg_val, mpc_rnd_t rnd_mode, mpfr_prec_t res_real_prec, mpfr_prec_t res_imag_prec);
+VALUE r_mpc_div(int argc, VALUE *argv, VALUE self_val)
+{
+  MP_COMPLEX *self;
+  VALUE rnd_mode_val;
+  VALUE  res_real_prec_val, res_imag_prec_val;
+  VALUE arg_val;
+
+  mpfr_prec_t real_prec, imag_prec;
+  mpfr_prec_t res_real_prec, res_imag_prec;
+  mpc_rnd_t rnd_mode;
+
+  mpc_get_struct(self_val,self);
+  real_prec = mpfr_get_prec(mpc_realref(self));
+  imag_prec = mpfr_get_prec(mpc_imagref(self));
+
+  //if (argc > 0 && TYPE(argv[0]) == T_HASH) {
+  //  rb_mpc_get_hash_arguments (&rnd_mode, &real_prec, &imag_prec, argv[0]);
+    //res_real_prec = real_prec;
+    //res_imag_prec = imag_prec;
+  //} else {
+    rb_scan_args (argc, argv, "13", &arg_val, &rnd_mode_val, &res_real_prec_val, &res_imag_prec_val);
+
+    r_mpc_set_default_args (rnd_mode_val, res_real_prec_val, res_imag_prec_val,
+                           &rnd_mode,    &res_real_prec,    &res_imag_prec,
+                                              real_prec,         imag_prec);
+  //}
+
+  //return res_val;
+  return r_mpc_div_do_the_work(self_val, arg_val, rnd_mode, res_real_prec, res_imag_prec);
+}
+
+VALUE r_mpc_div2(VALUE self_val, VALUE arg_val)
+{
+  MP_COMPLEX *self;
+
+  mpfr_prec_t res_real_prec, res_imag_prec;
+
+  mpc_get_struct(self_val, self);
+  res_real_prec = mpfr_get_prec(mpc_realref(self));
+  res_imag_prec = mpfr_get_prec(mpc_imagref(self));
+
+  return r_mpc_div_do_the_work(self_val, arg_val, MPC_RNDNN, res_real_prec, res_imag_prec);
+}
+
+VALUE r_mpc_div_do_the_work(VALUE self_val, VALUE arg_val, mpc_rnd_t rnd_mode, mpfr_prec_t res_real_prec, mpfr_prec_t res_imag_prec) {
+  MP_COMPLEX *self, *res, *arg_c;
+  MP_INT *arg_z;
+  MP_FLOAT *arg_f;
+  VALUE res_val;
+
+  mpc_get_struct(self_val,self);
+
+  if (FIXNUM_P (arg_val)) {
+    mpc_make_struct_init3 (res_val, res, res_real_prec, res_imag_prec);
+    if (FIX2NUM (arg_val) >= 0) {
+      mpc_div_ui (res, self,  FIX2NUM (arg_val), rnd_mode);
+    } else {
+      mpc_div_ui (res, self, -FIX2NUM (arg_val), rnd_mode);
+      mpc_neg (res, res, rnd_mode);
+    }
+  } else if (BIGNUM_P (arg_val)) {
+    mpc_make_struct_init3 (res_val, res, res_real_prec, res_imag_prec);
+    mpz_temp_from_bignum (arg_z, arg_val);
+    mpc_set_z (res, arg_z, MPC_RNDNN);
+    mpz_temp_free (arg_z);
+    mpc_div (res, self, res, rnd_mode);
+  } else if (GMPZ_P (arg_val)) {
+    mpc_make_struct_init3 (res_val, res, res_real_prec, res_imag_prec);
+    mpz_get_struct (arg_val, arg_z);
+    mpc_set_z (res, arg_z, MPC_RNDNN);
+    mpc_div (res, self, res, rnd_mode);
+  } else if (GMPF_P (arg_val)) {
+    mpc_make_struct_init3 (res_val, res, res_real_prec, res_imag_prec);
+    mpf_get_struct (arg_val, arg_f);
+    mpc_div_fr (res, self, arg_f, rnd_mode);
+  } else if (MPC_P (arg_val)) {
+    mpc_make_struct_init3 (res_val, res, res_real_prec, res_imag_prec);
+    mpc_get_struct (arg_val, arg_c);
+    mpc_div (res, self, arg_c, rnd_mode);
+  } else {
+    typeerror(FXC);
+  }
+
+  return res_val;
+}
+
 MPC_SINGLE_FUNCTION(neg)
 
 /*
@@ -905,6 +992,34 @@ VALUE r_mpc_abs(int argc, VALUE *argv, VALUE self)
   return abs;
 }
 
+/*
+ * call-seq:
+ *   c.norm
+ *   c.norm(rounding_mode)
+ *
+ * Returns the norm of _c_ (i.e., the square of its absolute value), as a GMP_F float (an MPFR float, really).
+ */
+VALUE r_mpc_norm(int argc, VALUE *argv, VALUE self)
+{
+  MP_COMPLEX *self_val;
+  MP_FLOAT *norm_val;
+  VALUE rnd_mode, norm;
+  mpfr_prec_t pr=0, pi=0;
+  mpc_rnd_t rnd_mode_val;
+
+  mpc_get_struct (self, self_val);
+
+  rb_scan_args (argc, argv, "01", &rnd_mode);
+  if (NIL_P (rnd_mode)) { rnd_mode_val = r_mpc_default_rounding_mode; }
+  else { rnd_mode_val = r_get_mpc_rounding_mode (rnd_mode); }
+
+  mpf_make_struct (norm, norm_val);
+  mpc_get_prec2 (&pr, &pi, self_val);
+  mpfr_init2 (norm_val, pr);
+  mpc_norm (norm_val, self_val, rnd_mode_val);
+  return norm;
+}
+
 /*********************************************************************
  *    Power and Logarithm Functions                                  *
  *********************************************************************/
@@ -912,6 +1027,7 @@ VALUE r_mpc_abs(int argc, VALUE *argv, VALUE self)
 MPC_SINGLE_FUNCTION(sqrt)
 MPC_SINGLE_FUNCTION(exp)
 MPC_SINGLE_FUNCTION(log)
+MPC_SINGLE_FUNCTION(log10)
 
 /*********************************************************************
  *    Trigonometric Functions                                        *
@@ -964,20 +1080,22 @@ void Init_mpc() {
   rb_define_method (cMPC, "proj", r_mpc_proj, -1);
 
   // Basic Arithmetic Functions
-  rb_define_method (cMPC, "add", r_mpc_add,  -1);
-  rb_define_method (cMPC, "+",   r_mpc_add2,  1);
-  rb_define_method (cMPC, "sub", r_mpc_sub,  -1);
-  rb_define_method (cMPC, "-",   r_mpc_sub2,  1);
-  rb_define_method (cMPC, "neg", r_mpc_neg,  -1);
-  rb_define_method (cMPC, "-@",  r_mpc_neg2,  0);
-  rb_define_method (cMPC, "mul", r_mpc_mul,  -1);
-  rb_define_method (cMPC, "*",   r_mpc_mul2,  1);
-  rb_define_method (cMPC, "sqr", r_mpc_sqr, -1);
+  rb_define_method (cMPC, "add",   r_mpc_add,   -1);
+  rb_define_method (cMPC, "+",     r_mpc_add2,   1);
+  rb_define_method (cMPC, "sub",   r_mpc_sub,   -1);
+  rb_define_method (cMPC, "-",     r_mpc_sub2,   1);
+  rb_define_method (cMPC, "neg",   r_mpc_neg,   -1);
+  rb_define_method (cMPC, "-@",    r_mpc_neg2,   0);
+  rb_define_method (cMPC, "mul",   r_mpc_mul,   -1);
+  rb_define_method (cMPC, "*",     r_mpc_mul2,   1);
+  // TODO rb_define_method (cMPC, "mul_i", r_mpc_mul_i, -1);
+  rb_define_method (cMPC, "sqr",   r_mpc_sqr,   -1);
   // TODO rb_define_method (cMPC, "fma", r_mpc_fma, 2);
-  // TODO rb_define_method (cMPC, "/", r_mpc_div, 1);
-  rb_define_method (cMPC, "conj", r_mpc_conj, -1);
-  rb_define_method (cMPC, "abs", r_mpc_abs, -1);
-  // TODO rb_define_method (cMPC, "norm", r_mpc_norm, 0);
+  rb_define_method (cMPC, "div",   r_mpc_div,   -1);
+  rb_define_method (cMPC, "/",     r_mpc_div2,   1);
+  rb_define_method (cMPC, "conj",  r_mpc_conj,  -1);
+  rb_define_method (cMPC, "abs",   r_mpc_abs,   -1);
+  rb_define_method (cMPC, "norm",  r_mpc_norm,  -1);
   // TODO rb_define_method (cMPC, "mul_2exp", r_mpc_mul_2exp, 1);
   // TODO rb_define_method (cMPC, "div_2exp", r_mpc_div_2exp, 1);
 
@@ -986,7 +1104,7 @@ void Init_mpc() {
   // TODO rb_define_method (cMPC, "**", r_mpc_pow, 1);
   rb_define_method (cMPC, "exp", r_mpc_exp, -1);
   rb_define_method (cMPC, "log", r_mpc_log, -1);
-  // TODO rb_define_method (cMPC, "log10", r_mpc_log10, -1);
+  rb_define_method (cMPC, "log10", r_mpc_log10, -1);
 
   // Trigonometric Functions
   rb_define_method (cMPC, "sin", r_mpc_sin, -1);

data/manual.md

@@ -455,6 +455,7 @@ according to $rounding\_mode$.
   \texttt{a = MPC.new(GMP::F("3.1416", 12)) \#=> (3.1416 +0) \newline
           a + 0 \qqqquad\qqqquad\qquad\qqqquad \#=> (3.1416 +0) \newline
           a + 1 \qqqquad\qqqquad\qqqquad\qquad \#=> (4.1406 +0) \newline
+          a - -7 \qqqquad\qqqquad\qqqquad\quad\  \#=> (-3.8584 +0) \newline
           a + GMP::Z(1024) \qqqquad\qqqquad\  \#=> (1.0270e+3 +0) \newline
           a + 2**66 \qqqquad\qqqquad\qqqquad \#=> (7.3787e+19 +0) \newline
           a + GMP::F("3.1416", 12) \qqqquad\  \#=> (6.2832 +0) \newline}
@@ -472,6 +473,7 @@ according to $rounding\_mode$.
   \texttt{a = MPC.new(GMP::F("3.1416", 12)) \#=> (3.1416 +0) \newline
           a - 0 \qqqquad\qqqquad\qquad\qqqquad \#=> (3.1416 +0) \newline
           a - 1 \qqqquad\qqqquad\qqqquad\qquad \#=> (2.1416 +0) \newline
+          a - -7 \qqqquad\qqqquad\qqqquad\quad\  \#=> (1.0141e+1 +0) \newline
           a - GMP::Z(1024) \qqqquad\qqqquad\  \#=> (-1.0208e+3 +0) \newline
           a - 2**66 \qqqquad\qqqquad\qqqquad \#=> (-7.3787e+19 +0) \newline
           a - GMP::F("3.1416", 12) \qqqquad\  \#=> (+0 +0) \newline}
@@ -489,12 +491,33 @@ according to $rounding\_mode$.
   \texttt{a = MPC.new(GMP::F("3.1416", 12)) \#=> (3.1416 +0) \newline
           a * 0 \qqqquad\qqqquad\qquad\qqqquad \#=> (+0 +0) \newline
           a * 1 \qqqquad\qqqquad\qqqquad\qquad \#=> (3.1416 +0) \newline
+          a * -7 \qqqquad\qqqquad\qqqquad\quad\  \#=> (-2.1992e+1 -0)\newline
           a * GMP::Z(1024) \qqqquad\qqqquad\  \#=> (3.2170e+3 +0) \newline
           a * 2**66 \qqqquad\qqqquad\qqqquad \#=> (2.3181e+20 +0) \newline
           a * GMP::F("3.1416", 12) \qqqquad\  \#=> (9.8711 +0) \newline}
 }
 \end{tabular}
 
+\begin{tabular}{p{\methwidth} l r p{\returnwidth}}
+\toprule
+\textbf{div, /} & & MPC\#div($op2$) & $\rightarrow complex$ \\
+& & MPC\#div($op2$, $rounding\_mode$ = MPC::MPC\_RNDNN) & $\rightarrow complex$ \\
+& & $op1 / op2$ & $\rightarrow complex$ \\
+\cmidrule(r){2-4}
+& \multicolumn{3}{p{\defnwidth}}{
+  Return the quotient of the receiver ($op1$) and $op2$, rounded according to
+  $rounding\_mode$. $op2$ may be a \texttt{Fixnum}, \texttt{GMP::Z}, \texttt{Bignum}, or \texttt{GMP::F}.\newline
+
+  \texttt{a = MPC.new(GMP::F("3.1416", 12)) \#=> (3.1416 +0) \newline
+          a / 0 \qqqquad\qqqquad\qquad\qqqquad \#=> (@Inf@ @NaN@) \newline
+          a / 1 \qqqquad\qqqquad\qqqquad\qquad \#=> (3.1416 +0) \newline
+          a / -7 \qqqquad\qqqquad\qqqquad\quad\  \#=> (-4.4885e-1 -0)\newline
+          a / GMP::Z(1024) \qqqquad\qqqquad\  \#=> (3.0680e-3 +0) \newline
+          a / 2**66 \qqqquad\qqqquad\qqqquad \#=> (4.9088e-2 +0) \newline
+          a / GMP::F("3.1416", 12) \qqqquad\  \#=> (1.0000 +0) \newline}
+}
+\end{tabular}
+
 \ifdef{HTML}
 <table>
   <tr class="new-method">
@@ -516,6 +539,7 @@ $rounding\_mode$.
 <pre><code>a = MPC.new(GMP::F("3.1416", 12)) #=> (3.1416 +0)
 a + 0                             #=> (3.1416 +0)
 a + 1                             #=> (4.1406 +0)
+a + -7                            #=> (-3.8584 +0)
 a + GMP::Z(1024)                  #=> (1.0270e+3 +0)
 a + 2**66                         #=> (7.3787e+19 +0)
 a + GMP::F("3.1416", 12)          #=> (6.2832 +0)
@@ -542,6 +566,7 @@ $rounding\_mode$.
 <pre><code>a = MPC.new(GMP::F("3.1416", 12)) #=> (3.1416 +0)
 a - 0                             #=> (3.1416 +0)
 a - 1                             #=> (2.1416 +0)
+a - -7                            #=> (1.0141e+1 +0)
 a - GMP::Z(1024)                  #=> (-1.0208e+3 +0)
 a - 2**66                         #=> (-7.3787e+19 +0)
 a - GMP::F("3.1416", 12)          #=> (+0 +0)
@@ -568,9 +593,37 @@ $rounding\_mode$.
 <pre><code>a = MPC.new(GMP::F("3.1416", 12)) #=> (3.1416 +0)
 a * 0                             #=> (+0 +0)
 a * 1                             #=> (3.1416 +0)
+a * -7                            #=> (-2.1992e+1 -0)
 a * GMP::Z(1024)                  #=> (3.2170e+3 +0)
 a * 2**66                         #=> (2.3181e+20 +0)
 a * GMP::F("3.1416", 12)          #=> (9.8711 +0)
+</code></pre>
+    </td>
+  </tr>
+
+  <tr class="new-method">
+    <th>div, /</th><th>`MPC#div(op2)` $\rightarrow$ _complex_
+  </tr>
+  <tr>
+    <th></th>   <th><code>MPC#div(_op2_, _rounding_mode_ = MPC::MPC_RNDNN)</code> $\rightarrow$ _complex_
+</th>
+  </tr>
+  <tr class="last-header">
+    <th></th>    <th>`op1 / op2` $\rightarrow$ _complex_
+  </tr>
+  <tr>
+    <td></td>
+    <td>
+Return the quotient of the receiver ($op1$) and $op2$, rounded according to
+$rounding\_mode$.
+
+<pre><code>a = MPC.new(GMP::F("3.1416", 12)) #=> (3.1416 +0)
+a / 0                             #=> (@Inf@ @NaN@)
+a / 1                             #=> (3.1416 +0)
+a / -7                            #=> (-4.4885e-1 -0)
+a / GMP::Z(1024)                  #=> (3.0680e-3 +0)
+a / 2**66                         #=> (4.9088e-2 +0)
+a / GMP::F("3.1416", 12)          #=> (1.0000 +0)
 </code></pre>
     </td>
   </tr>
@@ -629,7 +682,16 @@ a * GMP::F("3.1416", 12)          #=> (9.8711 +0)
 
 \toprule
 \textbf{log10} & & MPC\#log10() & $\rightarrow$ \textit{complex} \\
-& \multicolumn{3}{p{\defnwidth}}{\textit{Not implemented yet.}}
+& & MPC\#log10(\textit{rounding\_mode} = MPC::MPC\_RNDNN, & \\
+& & \textit{precision} = \textit{mpfr\_default\_precision}) & $\rightarrow$ \textit{complex} \\
+& & MPC\#log10(\textit{options\_hash}) & $\rightarrow$ \textit{complex} \\
+\cmidrule(r){2-4}
+& \multicolumn{3}{p{\defnwidth}}{
+  Return the base-10 logarithm of the receiver, rounded according to
+  $rounding\_mode$. The principal branch is chosen, with the branch cut on the
+  negative real axis, so that the imaginary part of the result lies in 
+  $[-\pi, \pi]$ and $[-\pi/log(10), \pi/log(10)]$ respectively.
+}
 \end{tabular}
 
 \ifdef{HTML}
@@ -700,14 +762,23 @@ $[-\pi, \pi]$ and $[-\pi/log(10), \pi/log(10)]$ respectively.
     </td>
   </tr>
 
-
-  <tr class="new-method last-header">
-    <th>log10</th><th>`MPC#log10()` $\rightarrow$ _complex_
+  <tr class="new-method">
+    <th>log10</th><th>`MPC#log()` $\rightarrow$ _complex_
+  </tr>
+  <tr>
+    <th></th>   <th><code>MPC#log10(_rounding_mode_ = MPC::MPC_RNDNN, _precision_ = _mpfr_default_)</code> $\rightarrow$ _complex_
+</th>
+  </tr>
+  <tr class="last-header">
+    <th></th>   <th>`MPC#log10(options_hash)` $\rightarrow$ _complex_</th>
   </tr>
   <tr>
     <td></td>
     <td>
-_Not implemented yet._
+Return the base-10 logarithm of the receiver, rounded according to
+$rounding\_mode$. The principal branch is chosen, with the branch cut on the
+negative real axis, so that the imaginary part of the result lies in 
+$[-\pi, \pi]$ and $[-\pi/log(10), \pi/log(10)]$ respectively.
     </td>
   </tr>
 </table>

data/spec/log10_spec.rb

@@ -0,0 +1,39 @@
+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
+    actual = MPC.new([1, 0], 2).log10
+    actual.real.should eq 0
+    actual.imag.should eq 0
+  end
+
+  it 'should calculate the base 10 logarithm of 10 +- i*0' do
+    actual = MPC.new([GMP::F(10, 4), GMP::F(0, 2)]).log10
+    actual.real.should eq 1
+    actual.imag.should eq 0
+  end
+
+  it 'should calculate the base 10 logarithm of 100 +- i*0' do
+    actual = MPC.new([GMP::F(100, 5), GMP::F(0, 2)]).log10
+    actual.real.should eq 2
+    actual.imag.should 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
+    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],
+      [["0x1475c655fbc11p-48",  53, 16], [ "0x15d47c4cb2fba1p-52", 53, 16], MPC.new([GMP::F("-0x13", 5, 16),  GMP::F(0, 2)]), MPC::MPC_RNDNN],
+      [["0x1475c655fbc11p-48",  53, 16], ["-0x15d47c4cb2fba1p-52", 53, 16], MPC.new([GMP::F("-0x13", 5, 16), -GMP::F(0, 2)]), MPC::MPC_RNDNN],
+      [["0x1475c655fbc11p-48",  53, 16], ["-0x15d47c4cb2fba1p-53", 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.log10(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 log10.data, each a result of some bug or other thing
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gnu_mpc
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.8.1
   prerelease: 
 platform: ruby
 authors:
@@ -36,6 +36,7 @@ files:
 - spec/cosh_spec.rb
 - spec/exp_spec.rb
 - spec/hash_arguments_spec.rb
+- spec/log10_spec.rb
 - spec/log_spec.rb
 - spec/mpc_single_function_args_spec.rb
 - spec/neg_spec.rb
@@ -54,6 +55,7 @@ files:
 - spec/to_s_spec.rb
 - spec/version_spec.rb
 - README.md
+- CHANGELOG
 - manual.md
 - manual.pdf
 - COPYING.md