gnu_mpc 0.8.2 → 0.9.0

data/.rspec

@@ -0,0 +1,2 @@
+--colour
+--seed 11213

data/.yardopts

@@ -0,0 +1,2 @@
+--markup markdown
+ext/*.c

data/CHANGELOG

@@ -1,5 +1,27 @@
-* v 0.8.1
-  * Added MPC#/, MPC#div
-  * Added MPC#log10
-* v 0.8.0
-  * Most things
+### 0.9.0
+
+* documented MPC#proj
+* added MPC#arg, with documentation, and tests
+* added MPC#fma, wtih documentation, and tests
+* added MPC#prec2, with tests
+* added GMP::RandState#mpc_urandom, with tests
+* added MPC#** and MPC#pow, with tests
+* MPC#real and MPC#imag now take an optional precision, for the result.
+* added tests for `#new` args, and fixed `#new(value, real_prec, imag_prec)` bug
+* MPC#sub now accepts hash arguments (other bin-ops soon!)
+* Bumped rspec and converting tests to just use expect().
+* Travis is good.
+* For Travis, whose VMs can only reach MPC 0.9-4, we know have support for MPC 0.9
+
+### 0.8.2
+
+* Added MPC#mul_i with tests
+
+### 0.8.1
+
+* Added MPC#/, MPC#div
+* Added MPC#log10
+
+### 0.8.0
+
+* Most things

data/Gemfile

@@ -9,9 +9,11 @@ end
 group :development do
   gem 'yard'
   gem 'redcarpet'
-  if RUBY_PLATFORM =~ /darwin/i
+
+  group :darwin do
     gem 'rb-fsevent', :require => false
   end
+
   gem 'guard-rspec'
   gem 'guard-shell'
 end

data/README.md

@@ -6,6 +6,47 @@ This gem provides Ruby bindings to the GNU MPC library.
 Methods
 =======
 
+"Initialization" Methods
+------------------------
+
+MPC.new(7)      # (7,0)
+MPC.new(7, 32)  # (7,0) with precision 32
+MPC#prec        # precision if real and imag precisions are the same, 0 otherwise
+MPC#prec2       # real and imaginary precisions, as a 2-element Array
+
+Projection and Decomposing Methods
+----------------------------------
+
+```ruby
+MPC#real   # real part
+MPC#imag   # imaginary part
+MPC#arg    # argument
+MPC#proj   # projection
+```
+
+Basic Arithmetic Methods
+------------------------
+
+```ruby
+MPC#add(w)    # add with w
+MPC#sub(w)    # difference with w
+MPC#mul(w)    # multiply with w
+MPC#div(w)    # divide by w
+MPC#fma(w,x)  # multiple by w, then add with x
+```
+
+Power and Logarithm Methods
+---------------------------
+
+```ruby
+MPC#sqrt      # square root
+MPC#pow(w)    # raise to the power w
+MPC#** w      # raise to the power w
+MPC#exp       # exponential
+MPC#log       # natural logarithm
+MPC#log10     # base-10 logarithm
+```
+
 Trigonometric Methods
 ---------------------
 
@@ -23,13 +64,27 @@ MPC#acos   # inverse cosine
 MPC#atan   # inverse tangent
 ```
 
-Each of these methods accepts optional arguments to specify the rounding mode, and precision, in the following fashions:
+Miscellaneous Functions
+-----------------------
+
+```ruby
+GMP::RandState#mpc_urandom  # uniformly distributed random complex number within
+                            # [0,1] x [0,1]
+```
+
+...
+
+Each of these methods accepts optional arguments to specify the rounding mode,
+and precision, in the following fashions:
 
 ```
 z = MPC.new(0, 1)
-z.sin()                                    # default rounding mode; precision of the receiver is applied to the return value
-z.sin(MPC::MPC_RNDZZ)                      # MPC_RNDZZ rounding mode; precision of the receiver is applied to the return value
-z.sin(MPC::MPC_RNDNN, 64)                  # MPC_RNDNN rounding mode; precision of both real and imaginary parts of return value is 64
+z.sin()                                    # default rounding mode; precision of the receiver is
+                                           # applied to the return value
+z.sin(MPC::MPC_RNDZZ)                      # MPC_RNDZZ rounding mode; precision of the receiver
+                                           # is applied to the return value
+z.sin(MPC::MPC_RNDNN, 64)                  # MPC_RNDNN rounding mode; precision of both real and
+                                           # imaginary parts of return value is 64
 z.sin(MPC::MPC_RNDNN, 64, 128)             # MPC_RNDNN rounding mode; precision
                                            # of real part of return value is 64,
                                            # imaginary part is 128
@@ -44,4 +99,5 @@ z.sin(:pre_real => 64, :prec_imag => 128)  # default rounding mode; precision of
                                            # imaginary part is 128
 ```
 
-Either the ordered list of arguments, or the options Hash may be passed; they cannot be mixed.
+Either the ordered list of arguments, or the options Hash may be passed; they
+cannot be mixed.

data/Rakefile

@@ -4,7 +4,7 @@ require "rspec/core/rake_task"
 DEPENDENCIES_DIR = '/usr/local'
 
 task :clean do
-  sh "cd ext && make clean"
+  sh "cd ext && make clean; echo"
 end
 
 task :extconf => [:clean] do
@@ -15,12 +15,20 @@ task :make => [:extconf] do
   sh "cd ext && make"
 end
 
-task :default => [:spec]
+task :console do
+  require 'irb'
+  require File.join(File.dirname(__FILE__), 'lib', 'mpc')
+  ARGV.clear
+  IRB.start
+end
 
 desc "Run all specs"
 RSpec::Core::RakeTask.new(:spec) do |t|
 end
 
+task :default => [:ci]
+task :ci => [:make, :spec]
+
 namespace :dependencies do
   task :list do
     suffix = (DEPENDENCIES_DIR.size+1)..-1
@@ -38,7 +46,7 @@ namespace :dependencies do
 end
 
 def gmp_opt
-  version = ENV['GMP'] || '5.0.5'
+  version = ENV['GMP'] || '5.1.3'
   '--with-gmp-dir='+File.join(DEPENDENCIES_DIR, "gmp-#{version}")
 end
 

data/ext/extconf.rb

@@ -37,7 +37,11 @@ unless have_macro('SIZEOF_INTPTR_T')
   check_sizeof('intptr_t')
 end
 
-$CFLAGS += ' -Wall -W -O6 -g'
+if try_compile('', '-O6')
+  $CFLAGS += ' -Wall -W -O6 -g'
+else
+  $CFLAGS += ' -Wall -W -O3 -g'
+end
 
 if not ok
   raise "Unable to build, correct above errors and rerun"

data/ext/gmprandstate.c

@@ -0,0 +1,54 @@
+#include <ruby_mpc.h>
+
+/**********************************************************************
+ *    MPC Random Numbers                                              *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   rand_state.mpc_urandom()
+ *
+ * From the MPC Manual:
+ *
+ * Generate a uniformly distributed random complex in the unit square [0,1] x [0,1].
+ */
+VALUE r_gmprandstate_mpc_urandom(int argc, VALUE *argv, VALUE self_val)
+{
+  MP_RANDSTATE *self;
+  MP_COMPLEX *res;
+  VALUE res_val;
+  unsigned long prec = 0;
+
+  if (argc > 1)
+    rb_raise (rb_eArgError, "wrong # of arguments (%d for 0 or 1)", argc);
+
+  mprandstate_get_struct (self_val, self);
+
+  if (argc == 1) {
+    if (FIXNUM_P (argv[0])) {
+      if (FIX2INT (argv[0]) >= 2)
+        prec = FIX2INT (argv[0]);
+      else
+        rb_raise (rb_eRangeError, "prec must be at least 2");
+    } else {
+      rb_raise (rb_eTypeError, "prec must be a Fixnum");
+    }
+  }
+
+  mpc_make_struct (res_val, res);
+  if (prec == 0) { mpc_init2 (res, mpfr_get_default_prec()); }
+  else           { mpc_init2 (res, prec); }
+
+  mpc_urandom (res, self);
+
+  return res_val;
+}
+
+void init_gmprandstate_mpc()
+{
+  mGMP = rb_define_module("GMP");
+  cGMP_RandState = rb_define_class_under(mGMP, "RandState", rb_cObject);
+
+  // Complex Random Numbers
+  rb_define_method(cGMP_RandState, "mpc_urandom", r_gmprandstate_mpc_urandom, -1);
+}

data/ext/mpc.c

@@ -25,18 +25,18 @@ VALUE r_mpc_##name(int argc, VALUE *argv, VALUE self_val)
 {                                                                                            \
   MP_COMPLEX *self, *res;                                                                    \
   VALUE rnd_mode_val;                                                                        \
-  VALUE  res_real_prec_val, res_imag_prec_val;                                               \
+  VALUE res_real_prec_val, res_imag_prec_val;                                                \
   VALUE res_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));                                              \
+  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) {                                                 \
+  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;                                                               \
@@ -76,16 +76,22 @@ void r_mpc_set_default_args (VALUE rnd_mode_val,    VALUE res_real_prec_val,
 }
 
 void rb_mpc_get_hash_arguments(mpc_rnd_t *rnd_mode, mpfr_prec_t *real_prec, mpfr_prec_t *imag_prec, VALUE hash) {
-  VALUE rnd_mode_val;
-  VALUE real_prec_val;
-  VALUE rounding_mode_sym, rounding_sym, round_sym, rnd_sym;
-  VALUE precision_sym, prec_sym;
-  rounding_mode_sym = ID2SYM(rb_intern("rounding_mode"));
-  rounding_sym      = ID2SYM(rb_intern("rounding"));
-  round_sym         = ID2SYM(rb_intern("round"));
-  rnd_sym           = ID2SYM(rb_intern("rnd"));
-  precision_sym     = ID2SYM(rb_intern("precision"));
-  prec_sym          = ID2SYM(rb_intern("prec"));
+  VALUE rnd_mode_val,
+        real_prec_val, imag_prec_val,
+        rounding_mode_sym, rounding_sym, round_sym, rnd_sym,
+        precision_sym, prec_sym,
+        real_precision_sym, real_prec_sym, imag_precision_sym, imag_prec_sym;
+
+  rounding_mode_sym  = ID2SYM(rb_intern("rounding_mode"));
+  rounding_sym       = ID2SYM(rb_intern("rounding"));
+  round_sym          = ID2SYM(rb_intern("round"));
+  rnd_sym            = ID2SYM(rb_intern("rnd"));
+  precision_sym      = ID2SYM(rb_intern("precision"));
+  prec_sym           = ID2SYM(rb_intern("prec"));
+  real_precision_sym = ID2SYM(rb_intern("real_precision"));
+  real_prec_sym      = ID2SYM(rb_intern("real_prec"));
+  imag_precision_sym = ID2SYM(rb_intern("imag_precision"));
+  imag_prec_sym      = ID2SYM(rb_intern("imag_prec"));
 
   rnd_mode_val = rb_hash_aref(hash, rounding_mode_sym);
   if (rnd_mode_val == Qnil) { rnd_mode_val = rb_hash_aref(hash, rounding_sym); }
@@ -97,14 +103,26 @@ void rb_mpc_get_hash_arguments(mpc_rnd_t *rnd_mode, mpfr_prec_t *real_prec, mpfr
     *rnd_mode = __gmp_default_rounding_mode;
   }
 
-  /* TODO: allow prec */
-  /* TODO: allow real_prec, imag_prec */
-  real_prec_val = rb_hash_aref(hash, precision_sym);
-  if (real_prec_val == Qnil) { real_prec_val = rb_hash_aref(hash, prec_sym); }
+  real_prec_val = rb_hash_aref (hash, precision_sym);
+  if (real_prec_val == Qnil) { real_prec_val = rb_hash_aref (hash, prec_sym); }
   if (real_prec_val != Qnil) {
+    if (! FIXNUM_P (real_prec_val)) rb_raise (rb_eTypeError, "real precision must be a Fixnum.");
     *real_prec = FIX2INT (real_prec_val);
     *imag_prec = FIX2INT (real_prec_val);
   } else {
+    real_prec_val = rb_hash_aref (hash, real_precision_sym);
+    if (real_prec_val == Qnil) { real_prec_val = rb_hash_aref (hash, real_prec_sym); }
+    if (real_prec_val != Qnil) {
+      if (! FIXNUM_P (real_prec_val)) rb_raise (rb_eTypeError, "real precision must be a Fixnum.");
+      *real_prec = FIX2INT (real_prec_val);
+    }
+
+    imag_prec_val = rb_hash_aref (hash, imag_precision_sym);
+    if (imag_prec_val == Qnil) { imag_prec_val = rb_hash_aref (hash, imag_prec_sym); }
+    if (imag_prec_val != Qnil) {
+      if (! FIXNUM_P (imag_prec_val)) rb_raise (rb_eTypeError, "imag precision must be a Fixnum.");
+      *imag_prec = FIX2INT (imag_prec_val);
+    }
   }
 
   /* TODO: disallow any other args. Throw a fit. */
@@ -121,7 +139,7 @@ int rb_base_type_range_check(VALUE base)
   else {
     if (FIXNUM_P (base))
       if (FIX2NUM (base) >= 2 && FIX2NUM (base) <= 36)
-        base_val = FIX2NUM (base);
+        base_val = (int) FIX2NUM (base);
       else
         rb_raise (rb_eRangeError, "base must be between 2 and 36.");
     else
@@ -132,18 +150,54 @@ int rb_base_type_range_check(VALUE base)
 
 size_t rb_sig_figs_type_range_check(VALUE sig_figs)
 {
-  size_t sig_figs_val;
-  if (NIL_P (sig_figs)) { sig_figs_val = (size_t)(0); }
-  else {
-    if (FIXNUM_P (sig_figs))
-      if (FIX2NUM (sig_figs) >= 0)
-        sig_figs_val = (size_t)(FIX2NUM (sig_figs));
-      else
-        rb_raise (rb_eRangeError, "significant figures must be greater than or equal to 0.");
+  if (NIL_P (sig_figs)) {
+    return (size_t)(0);
+  }
+
+  if (FIXNUM_P (sig_figs))
+    if (FIX2NUM (sig_figs) >= 0)
+      return (size_t)(FIX2NUM (sig_figs));
     else
-      rb_raise (rb_eTypeError, "significant figures must be a Fixnum.");
+      rb_raise (rb_eRangeError, "significant figures must be greater than or equal to 0.");
+  else
+    rb_raise (rb_eTypeError, "significant figures must be a Fixnum.");
+}
+
+void r_mpc_init_mpc_res_and_set_rnd_mode(
+    MP_COMPLEX **res, mpc_rnd_t *rnd_mode,                   /* return args */
+    int argc, VALUE *argv, MP_COMPLEX *self, const char *scan_fmt)  /* args */
+{
+  VALUE rnd_mode_val, res_real_prec_val, res_imag_prec_val;
+  mpfr_prec_t real_prec, imag_prec;
+  mpfr_prec_t res_real_prec, res_imag_prec;
+  int hash_idx;
+
+  real_prec = mpfr_get_prec (mpc_realref (self));
+  imag_prec = mpfr_get_prec (mpc_imagref (self));
+
+  if (scan_fmt[0] == '0') {
+    hash_idx = 0;
+  } else {
+    hash_idx = 1;
+  }
+
+  if (argc > hash_idx && TYPE (argv[hash_idx]) == T_HASH) {
+    rb_mpc_get_hash_arguments (rnd_mode, &real_prec, &imag_prec, argv[hash_idx]);
+    res_real_prec = real_prec;
+    res_imag_prec = imag_prec;
+  } else {
+    if (scan_fmt[0] == '0') {
+      rb_scan_args (argc, argv, scan_fmt, &rnd_mode_val, &res_real_prec_val, &res_imag_prec_val);
+    } else {
+      rb_scan_args (argc, argv, scan_fmt, 0, &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 sig_figs_val;
+
+  mpc_init3 (*res, res_real_prec, res_imag_prec);
 }
 
 
@@ -221,24 +275,24 @@ mpc_rnd_t r_get_mpc_rounding_mode(VALUE rnd)
  * * Bignum
  *
  * @example
- *   MPC.new(5)  #=> 5
- *
- * @todo support #new(c, prec)
- * @todo support #new(c, prec_r, prec_i)
+ *   MPC.new(5)                   #=> (5,0)
+ *   MPC.new(1.111)               #=> (1.111,0)
+ *   MPC.new(5, 32)               #=> (5,0) with precision 32
+ *   MPC.new([1.0, 1.0], 32, 64)  #=> (1.0,1.0) with real precision 32, imag precision 64
  */
 VALUE r_mpcsg_new(int argc, VALUE *argv, VALUE klass)
 {
-  MP_COMPLEX *res_val;
-  VALUE res;
+  MP_COMPLEX *res;
+  VALUE res_val;
   (void)klass;
 
   if (argc > 3)
     rb_raise (rb_eArgError, "wrong # of arguments (%d for 0, 1, 2, or 3)", argc);
 
-  mpc_make_struct (res, res_val);
-  rb_obj_call_init (res, argc, argv);
+  mpc_make_struct (res_val, res);
+  rb_obj_call_init (res_val, argc, argv);
 
-  return res;
+  return res_val;
 }
 
 VALUE r_mpc_initialize(int argc, VALUE *argv, VALUE self)
@@ -266,11 +320,11 @@ VALUE r_mpc_initialize(int argc, VALUE *argv, VALUE self)
   //           OR argv[0] is value, argv[1] is rnd
   if (argc >= 2) {
     if (FIXNUM_P (argv[1])) {
-      if (FIX2INT (argv[1]) >= 0)
+      if (FIX2INT (argv[1]) >= 2)
         prec = FIX2INT (argv[1]);
       else {
         mpc_init2 (self_val, mpfr_get_default_prec());
-        rb_raise (rb_eRangeError, "prec must be non-negative");
+        rb_raise (rb_eRangeError, "prec must be at least 2");
       }
     } else if (MPCRND_P (argv[1])) {
       rnd_mode_val = r_get_mpc_rounding_mode(argv[1]);
@@ -315,8 +369,12 @@ VALUE r_mpc_initialize(int argc, VALUE *argv, VALUE self)
   // argc = 4 ==> argv[0] is value, argv[1] is prec_r, argv[2] is prec_i, argv[3] is rnd
   // TODO
 
-  if (prec == 0)
+  if (prec == 0 && prec_re == 0)
+    /* precision was not specified */
     mpc_init2 (self_val, mpfr_get_default_prec());
+  else if (prec == 0)
+    /* precision was specified in two parts */
+    mpc_init3 (self_val, prec_re, prec_im);
   else
     mpc_init2 (self_val, prec);
 
@@ -345,7 +403,6 @@ void mpc_set_value(MP_COMPLEX *self_val, VALUE arg, mpc_rnd_t rnd)
   MP_FLOAT   *arg_val_f, *arg_val_f_im;
   MP_COMPLEX *arg_val_c;
   VALUE arg_re, arg_im;
-  int result;
 
   if (FIXNUM_P (arg)) {
     mpc_set_si(self_val, FIX2NUM (arg), rnd);
@@ -358,7 +415,10 @@ void mpc_set_value(MP_COMPLEX *self_val, VALUE arg, mpc_rnd_t rnd)
     mpz_get_struct (arg, arg_val_z);
     mpc_set_z (self_val, arg_val_z, rnd);
   // TODO STRING_P
-  // TODO BIGNUM_P
+  } else if (BIGNUM_P (arg)) {
+    mpz_temp_from_bignum (arg_val_z, arg);
+    mpc_set_z (self_val, arg_val_z, rnd);
+    mpz_temp_free (arg_val_z);
   } else if (MPC_P (arg)) {
     mpc_get_struct (arg, arg_val_c);
     mpc_set (self_val, arg_val_c, rnd);
@@ -370,6 +430,7 @@ void mpc_set_value(MP_COMPLEX *self_val, VALUE arg, mpc_rnd_t rnd)
       //rb_raise(rb_eArgError, "Value Array must contain exactly two elements, the real value, and the imaginary value.");
     arg_re = rb_ary_shift(arg);
     arg_im = rb_ary_shift(arg);
+    // TODO allow different classes for re and im args
     if (FIXNUM_P (arg_re) && FIXNUM_P (arg_im)) {
       mpc_set_si_si (self_val, FIX2NUM (arg_re), FIX2NUM (arg_im), rnd);
     } else if (FLOAT_P (arg_re) && FLOAT_P (arg_im)) {
@@ -387,7 +448,12 @@ void mpc_set_value(MP_COMPLEX *self_val, VALUE arg, mpc_rnd_t rnd)
       mpf_get_struct (arg_im, arg_val_f_im);
       mpc_set_fr_fr (self_val, arg_val_f, arg_val_f_im, rnd);
     // TODO STRING_P
-    // TODO BIGNUM_P
+    } else if (BIGNUM_P (arg_re) && BIGNUM_P (arg_im)) {
+      mpz_temp_from_bignum (arg_val_z, arg_re);
+      mpz_temp_from_bignum (arg_val_z_im, arg_im);
+      mpc_set_z_z (self_val, arg_val_z, arg_val_z_im, rnd);
+      mpz_temp_free (arg_val_z);
+      mpz_temp_free (arg_val_z_im);
     } else
       rb_raise(rb_eTypeError, "Real and imaginary values must be of the same type.");
   } else {
@@ -402,11 +468,27 @@ void mpc_set_value(MP_COMPLEX *self_val, VALUE arg, mpc_rnd_t rnd)
  * If the real and imaginary part of _c_ have the same precision, it is returned. Otherwise,
  * 0 is returned.
  */
-VALUE r_mpc_prec(VALUE self)
+VALUE r_mpc_prec(VALUE self_val)
 {
-  MP_COMPLEX *self_val;
-  mpc_get_struct (self, self_val);
-  return INT2NUM (mpc_get_prec (self_val));
+  MP_COMPLEX *self;
+  mpc_get_struct (self_val, self);
+  return INT2NUM (mpc_get_prec (self));
+}
+
+/*
+ * call-seq:
+ *   c.prec2
+ *
+ * Returns the precision of the real part and imaginary part of _c_.
+ */
+VALUE r_mpc_prec2(VALUE self_val)
+{
+  MP_COMPLEX *self;
+  mpfr_prec_t prec_re;
+  mpfr_prec_t prec_im;
+  mpc_get_struct (self_val, self);
+  mpc_get_prec2 (&prec_re, &prec_im, self);
+  return rb_assoc_new (INT2NUM (prec_re), INT2NUM (prec_im));
 }
 
 
@@ -419,34 +501,29 @@ VALUE r_mpc_prec(VALUE self)
  *   c.to_s
  *
  * Returns the decimal representation of the real part and imaginary part of _c_, as a String.
- *
- * @TODO type check, range check optional argument: rounding mode
  */
-VALUE r_mpc_to_s(int argc, VALUE *argv, VALUE self)
+VALUE r_mpc_to_s(int argc, VALUE *argv, VALUE self_val)
 {
-  MP_COMPLEX *self_val;
+  MP_COMPLEX *self;
   char *str;
-  VALUE base, sig_figs, rnd_mode, res;
-  int base_val;
-  size_t sig_figs_val;
-  mpc_rnd_t rnd_mode_val;
-  //mp_exp_t exponent;
+  VALUE base_val, sig_figs_val, rnd_mode_val, res_val;
+  int base;
+  size_t sig_figs;
+  mpc_rnd_t rnd_mode;
 
-  mpc_get_struct (self, self_val)
+  mpc_get_struct (self_val, self)
 
-  rb_scan_args (argc, argv, "03", &base, &sig_figs, &rnd_mode);
-  base_val = rb_base_type_range_check (base);
-  sig_figs_val = rb_sig_figs_type_range_check (sig_figs);
-  //if (NIL_P (sig_figs)) { sig_figs_val = (size_t)(0); }
-  //else {                  sig_figs_val = (size_t)(FIX2NUM(sig_figs)); }
-  if (NIL_P (rnd_mode)) { rnd_mode_val = r_mpc_default_rounding_mode; }
-  else {                  rnd_mode_val = r_get_mpc_rounding_mode(rnd_mode); }
+  rb_scan_args (argc, argv, "03", &base_val, &sig_figs_val, &rnd_mode_val);
+  base = rb_base_type_range_check (base_val);
+  sig_figs = rb_sig_figs_type_range_check (sig_figs_val);
+  if (NIL_P (rnd_mode_val)) { rnd_mode = r_mpc_default_rounding_mode; }
+  else {                      rnd_mode = r_get_mpc_rounding_mode (rnd_mode_val); }
 
-  str = mpc_get_str (base_val, sig_figs_val, self_val, rnd_mode_val);
-  res = rb_str_new2 (str);
+  str = mpc_get_str (base, sig_figs, self, rnd_mode);
+  res_val = rb_str_new2 (str);
 
   mpc_free_str (str);
-  return res;
+  return res_val;
 }
 
 
@@ -454,37 +531,37 @@ VALUE r_mpc_to_s(int argc, VALUE *argv, VALUE self)
  *    Comparison Functions                                           *
  *********************************************************************/
 
-int mpc_cmp_value(MP_COMPLEX *self_val, VALUE arg)
+int mpc_cmp_value(MP_COMPLEX *self, VALUE arg_val)
 {
-  MP_COMPLEX *arg_val;
+  MP_COMPLEX *arg;
   int result;
 
-  if (MPC_P (arg)) {
-    mpc_get_struct (arg,arg_val);
-    return mpc_cmp (self_val, arg_val);
+  if (MPC_P (arg_val)) {
+    mpc_get_struct (arg_val, arg);
+    return mpc_cmp (self, arg);
   } else {
-    mpc_temp_init (arg_val, mpc_get_prec (self_val));
-    mpc_set_value (arg_val, arg, r_mpc_default_rounding_mode);
-    result = mpc_cmp (self_val, arg_val);
-    mpc_temp_free (arg_val);
+    mpc_temp_init (arg, mpc_get_prec (self));
+    mpc_set_value (arg, arg_val, r_mpc_default_rounding_mode);
+    result = mpc_cmp (self, arg);
+    mpc_temp_free (arg);
     return result;
   }
 }
 
-VALUE r_mpc_eq(VALUE self, VALUE arg)
+VALUE r_mpc_eq(VALUE self_val, VALUE arg_val)
 {
-  MP_COMPLEX *self_val;
-  mpc_get_struct (self,self_val);
-  return (mpc_cmp_value (self_val, arg) == 0) ? Qtrue : Qfalse;
+  MP_COMPLEX *self;
+  mpc_get_struct (self_val, self);
+  return (mpc_cmp_value (self, arg_val) == 0) ? Qtrue : Qfalse;
 }
 
-VALUE r_mpc_cmp(VALUE self, VALUE arg)
+VALUE r_mpc_cmp(VALUE self_val, VALUE arg_val)
 {
-  MP_COMPLEX *self_val;
+  MP_COMPLEX *self;
   int res;
-  mpc_get_struct (self, self_val);
-  res = mpc_cmp_value (self_val, arg);
-  return rb_assoc_new(INT2FIX(MPC_INEX_RE(res)), INT2FIX (MPC_INEX_IM(res)));
+  mpc_get_struct (self_val, self);
+  res = mpc_cmp_value (self, arg_val);
+  return rb_assoc_new (INT2FIX (MPC_INEX_RE (res)), INT2FIX (MPC_INEX_IM (res)));
 }
 
 
@@ -497,74 +574,83 @@ VALUE r_mpc_cmp(VALUE self, VALUE arg)
  * MPC as self, calls mpc_fname on the contained mpc_t, whose
  * arguments are exactly (0) the return argument (an mpfr_t), (1) self,
  * and (2) the rounding mode.
- *
- * TODO FINISH!!!
  */
-#define DEFUN_COMPLEX2FLOAT(fname,mpz_fname)                   \
-static VALUE r_mpc_##fname(int argc, VALUE *argv, VALUE self)  \
-{                                                              \
-  MP_COMPLEX *self_val;                                        \
-  MP_FLOAT *res_val;                                           \
-  VALUE rnd_mode, res_prec, res;                               \
-  mpfr_prec_t prec, res_prec_value;                            \
-  mpc_rnd_t rnd_mode_val;                                      \
+#define DEFUN_COMPLEX2FLOAT(fname, prec_src)                                 \
+static VALUE r_mpc_##fname(int argc, VALUE *argv, VALUE self_val)            \
+{                                                                            \
+  MP_COMPLEX *self;                                                          \
+  MP_FLOAT *res;                                                             \
+  VALUE rnd_mode_val, res_val, res_prec_val;                                 \
+                                                                             \
+  mpfr_prec_t real_prec, imag_prec;                                          \
+  mpfr_prec_t res_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_prec = prec_src;                                                     \
+  } else {                                                                   \
+    rb_scan_args (argc, argv, "02", &rnd_mode_val, &res_prec_val);           \
+                                                                             \
+    if (NIL_P (rnd_mode_val)) { rnd_mode = __gmp_default_rounding_mode; }    \
+    else { rnd_mode = r_mpc_get_rounding_mode(rnd_mode_val); }               \
+                                                                             \
+    if (NIL_P (res_prec_val)) { res_prec = prec_src; }                       \
+    else { res_prec = FIX2INT(res_prec_val); }                               \
+  }                                                                          \
+                                                                             \
+  mpf_make_struct (res_val, res);                                            \
+  mpfr_init2 (res, res_prec);                                                \
+  mpc_##fname (res, self, rnd_mode);                                         \
+                                                                             \
+  return res_val;                                                            \
+}
+
 
 /*
  * call-seq:
  *   c.real
  *   c.real(rounding_mode)
+ *   c.real(rounding_mode, precision)
  *
  * Returns the real part of _c_ as a GMP_F float (an MPFR float, really).
  */
-VALUE r_mpc_real(int argc, VALUE *argv, VALUE self)
-{
-  MP_COMPLEX *self_val;
-  MP_FLOAT *real_val;
-  VALUE rnd_mode, real;
-  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 (real, real_val);
-  mpc_get_prec2 (&pr, &pi, self_val);
-  mpfr_init2 (real_val, pr);
-  mpc_real (real_val, self_val, rnd_mode_val);
-  return real;
-}
+DEFUN_COMPLEX2FLOAT(real, real_prec)
 
 /*
  * call-seq:
  *   c.imag
  *   c.imag(rounding_mode)
+ *   c.imag(rounding_mode, precision)
  *
  * Returns the imaginary part of _c_ as a GMP_F float (an MPFR float, really).
  */
-VALUE r_mpc_imag(int argc, VALUE *argv, VALUE self)
-{
-  MP_COMPLEX *self_val;
-  MP_FLOAT *imag_val;
-  VALUE rnd_mode, imag;
-  mpfr_prec_t pr=0, pi=0;
-  mpc_rnd_t rnd_mode_val;
-
-  mpc_get_struct (self, self_val);
+DEFUN_COMPLEX2FLOAT(imag, imag_prec)
 
-  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 (imag, imag_val);
-  mpc_get_prec2 (&pr, &pi, self_val);
-  mpfr_init2 (imag_val, pr);
-  mpc_imag (imag_val, self_val, rnd_mode_val);
-  return imag;
-}
+/*
+ * call-seq:
+ *   c.arg
+ *   c.arg(rounding_mode)
+ *   c.arg(rounding_mode, precision)
+ *
+ * Returns the argument of _c_ (with a branch cut along the negative real axis)
+ * as a GMP_F float (an MPFR float, really).
+ */
+DEFUN_COMPLEX2FLOAT(arg, real_prec)
 
+/*
+ * call-seq:
+ *   c.proj
+ *   c.proj(rounding_mode)
+ *   c.proj(rounding_mode, precision)
+ *
+ * Returns the projection of _c_ onto the Riemann sphere as a GMP_F float (an
+ * MPFR float, really).
+ */
 MPC_SINGLE_FUNCTION(proj)
 
 /*********************************************************************
@@ -678,83 +764,64 @@ VALUE r_mpc_add_do_the_work(VALUE self_val, VALUE arg_val, mpc_rnd_t rnd_mode, m
   return res_val;
 }
 
-VALUE r_mpc_sub_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_sub_compute(MP_COMPLEX *self, VALUE arg_val, VALUE res_val, mpc_rnd_t rnd_mode);
 VALUE r_mpc_sub(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;
+  MP_COMPLEX *self, *res;
+  VALUE res_val;
   mpc_rnd_t rnd_mode;
+  /* TODO: test for argc >= 1 */
+  VALUE arg_val = argv[0];
 
   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);
-  //}
+  mpc_make_struct (res_val, res);
+  r_mpc_init_mpc_res_and_set_rnd_mode (&res, &rnd_mode, argc, argv, self, "13");
 
-  //return res_val;
-  return r_mpc_sub_do_the_work(self_val, arg_val, rnd_mode, res_real_prec, res_imag_prec);
+  return r_mpc_sub_compute (self, arg_val, res_val, rnd_mode);
 }
 
 VALUE r_mpc_sub2(VALUE self_val, VALUE arg_val)
 {
-  MP_COMPLEX *self;
-
+  MP_COMPLEX *self, *res;
+  VALUE res_val;
   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));
+  mpc_get_struct (self_val, self);
+  res_real_prec = mpfr_get_prec (mpc_realref (self));
+  res_imag_prec = mpfr_get_prec (mpc_imagref (self));
+
+  mpc_make_struct_init3 (res_val, res, res_real_prec, res_imag_prec);
 
-  return r_mpc_sub_do_the_work(self_val, arg_val, MPC_RNDNN, res_real_prec, res_imag_prec);
+  return r_mpc_sub_compute (self, arg_val, res_val, r_mpc_default_rounding_mode);
 }
 
-VALUE r_mpc_sub_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;
+VALUE r_mpc_sub_compute(MP_COMPLEX *self, VALUE arg_val, VALUE res_val, mpc_rnd_t rnd_mode) {
+  MP_COMPLEX *res, *arg_c;
   MP_INT *arg_z;
   MP_FLOAT *arg_f;
-  VALUE res_val;
 
-  mpc_get_struct(self_val,self);
+  mpc_get_struct(res_val, res);
 
   if (FIXNUM_P (arg_val)) {
-    mpc_make_struct_init3 (res_val, res, res_real_prec, res_imag_prec);
     if (FIX2NUM (arg_val) >= 0) {
       mpc_sub_ui (res, self,  FIX2NUM (arg_val), rnd_mode);
     } else {
       mpc_add_ui (res, self, -FIX2NUM (arg_val), 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_sub (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_sub (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_sub_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_sub (res, self, arg_c, rnd_mode);
   } else {
@@ -1057,7 +1124,65 @@ VALUE r_mpc_norm(int argc, VALUE *argv, VALUE self)
 MPC_SINGLE_FUNCTION(sqrt)
 MPC_SINGLE_FUNCTION(exp)
 MPC_SINGLE_FUNCTION(log)
+#if MPC_VERSION_MAJOR > 0
 MPC_SINGLE_FUNCTION(log10)
+#endif
+
+VALUE r_mpc_pow_compute(MP_COMPLEX *self, VALUE arg_val, VALUE res_val, mpc_rnd_t rnd_mode);
+VALUE r_mpc_pow(int argc, VALUE *argv, VALUE self_val)
+{
+  MP_COMPLEX *self, *res;
+  mpc_rnd_t rnd_mode;
+  VALUE res_val;
+  /* TODO: test for argc >= 1 */
+  VALUE arg_val = argv[0];
+  mpc_get_struct (self_val, self);
+  mpc_make_struct (res_val, res);
+  r_mpc_init_mpc_res_and_set_rnd_mode (&res, &rnd_mode, argc, argv, self, "13");
+
+  return r_mpc_pow_compute(self, arg_val, res_val, rnd_mode);
+}
+
+VALUE r_mpc_pow2(VALUE self_val, VALUE arg_val)
+{
+  MP_COMPLEX *self, *res;
+  mpc_rnd_t rnd_mode;
+  VALUE res_val;
+  mpc_get_struct (self_val, self);
+  mpc_make_struct (res_val, res);
+  mpc_init3 (res, mpfr_get_prec (mpc_realref (self)), mpfr_get_prec (mpc_imagref (self)));
+  rnd_mode = r_mpc_default_rounding_mode;
+
+  return r_mpc_pow_compute(self, arg_val, res_val, rnd_mode);
+}
+
+VALUE r_mpc_pow_compute(MP_COMPLEX *self, VALUE arg_val, VALUE res_val, mpc_rnd_t rnd_mode) {
+  MP_INT *arg_z;
+  MP_FLOAT *arg_f;
+  MP_COMPLEX *res;
+
+  mpc_get_struct (res_val, res);
+
+  if (FIXNUM_P (arg_val)) {
+    mpc_pow_si (res, self, FIX2NUM (arg_val), rnd_mode);
+  } else if (BIGNUM_P (arg_val)) {
+    mpz_temp_from_bignum (arg_z, arg_val);
+    mpc_pow_z (res, self, arg_z, rnd_mode);
+    mpz_temp_free (arg_z);
+  } else if (GMPZ_P (arg_val)) {
+    mpz_get_struct (arg_val, arg_z);
+    mpc_pow_z (res, self, arg_z, rnd_mode);
+  } else if (FLOAT_P (arg_val)) {
+    mpc_pow_d (res, self, NUM2DBL (arg_val), rnd_mode);
+  } else if (GMPF_P (arg_val)) {
+    mpf_get_struct (arg_val, arg_f);
+    mpc_pow_fr (res, self, arg_f, rnd_mode);
+  } else {
+    typeerror(XBZFC);
+  }
+
+  return res_val;
+}
 
 /*********************************************************************
  *    Trigonometric Functions                                        *
@@ -1069,7 +1194,7 @@ MPC_SINGLE_FUNCTION(log10)
  *   z.sin(rounding_mode)
  *
  * Returns _sin(z)_, rounded according to `rounding_mode`.
- * s3
+ *
  */
 MPC_SINGLE_FUNCTION(sin)
 MPC_SINGLE_FUNCTION(cos)
@@ -1081,16 +1206,62 @@ MPC_SINGLE_FUNCTION(asin)
 MPC_SINGLE_FUNCTION(acos)
 MPC_SINGLE_FUNCTION(atan)
 
+/*
+ * call-seq:
+ *   a.fma(b, c)
+ *   a.fma(b, c, rounding_mode)
+ *
+ * Returns _a*b + c_, rounded according to `rounding_mode`, not rounding until
+ * the final calculation.
+ *
+ */
+VALUE r_mpc_fma(int argc, VALUE *argv, VALUE self_val)
+{
+  MP_COMPLEX *self, *arg1, *arg2, *res;
+  VALUE rnd_mode_val;
+  VALUE res_real_prec_val, res_imag_prec_val;
+  VALUE arg1_val, arg2_val, res_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 > 2 && TYPE(argv[2]) == T_HASH) {
+    rb_scan_args (argc, argv, "21", &arg1_val, &arg2_val, &rnd_mode_val);
+
+    rb_mpc_get_hash_arguments (&rnd_mode, &real_prec, &imag_prec, argv[2]);
+    res_real_prec = real_prec;
+    res_imag_prec = imag_prec;
+  } else {
+    rb_scan_args (argc, argv, "23", &arg1_val, &arg2_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);
+  }
+
+  mpc_get_struct (arg1_val, arg1);
+  mpc_get_struct (arg2_val, arg2);
+  mpc_make_struct_init3 (res_val, res, res_real_prec, res_imag_prec);
+  mpc_fma (res, self, arg1, arg2, rnd_mode);
+
+  return res_val;
+}
+
 void Init_mpc() {
   cMPC = rb_define_class ("MPC", rb_cNumeric);
 
-  rb_define_const (cMPC, "MPC_VERSION",       rb_str_new2(MPC_VERSION_STRING));
+  rb_define_const (cMPC, "MPC_VERSION", rb_str_new2(MPC_VERSION_STRING));
 
   // Initialization Functions and Assignment Functions
   rb_define_singleton_method (cMPC, "new", r_mpcsg_new, -1);
   rb_define_method (cMPC, "initialize", r_mpc_initialize, -1);
   rb_define_method (cMPC, "prec", r_mpc_prec, 0);
-  // TODO rb_define_method (cMPC, "prec2", r_mpc_prec, 0);
+  rb_define_method (cMPC, "prec2", r_mpc_prec2, 0);
   // TODO rb_define_method (cMPC, "prec=", r_mpc_prec, 1);
 
   // Conversion Functions
@@ -1106,7 +1277,7 @@ void Init_mpc() {
   // Projection and Decomposing Functions
   rb_define_method (cMPC, "real", r_mpc_real, -1);
   rb_define_method (cMPC, "imag", r_mpc_imag, -1);
-  // TODO rb_define_method (cMPC, "arg", r_mpc_arg, 0);
+  rb_define_method (cMPC, "arg",  r_mpc_arg,  -1);
   rb_define_method (cMPC, "proj", r_mpc_proj, -1);
 
   // Basic Arithmetic Functions
@@ -1120,7 +1291,7 @@ void Init_mpc() {
   rb_define_method (cMPC, "*",     r_mpc_mul2,   1);
   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);
+  rb_define_method (cMPC, "fma",   r_mpc_fma,   -1);
   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);
@@ -1131,10 +1302,13 @@ void Init_mpc() {
 
   // Power Functions and Logarithm
   rb_define_method (cMPC, "sqrt", r_mpc_sqrt, -1);
-  // 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);
+  rb_define_method (cMPC, "pow",  r_mpc_pow,  -1);
+  rb_define_method (cMPC, "**",   r_mpc_pow2,  1);
+  rb_define_method (cMPC, "exp",  r_mpc_exp,  -1);
+  rb_define_method (cMPC, "log",  r_mpc_log,  -1);
+#if MPC_VERSION_MAJOR > 0
   rb_define_method (cMPC, "log10", r_mpc_log10, -1);
+#endif
 
   // Trigonometric Functions
   rb_define_method (cMPC, "sin", r_mpc_sin, -1);
@@ -1151,8 +1325,6 @@ void Init_mpc() {
   // TODO rb_define_method (cMPC, "acosh", r_mpc_acosh, -1);
   // TODO rb_define_method (cMPC, "atanh", r_mpc_atanh, -1);
 
-  // Miscellaneous Functions
-  // TODO rb_define_method (cMPC, "urandom", r_mpc_urandom, 1);
-
-  init_mpcrnd();
+  init_mpcrnd ();
+  init_gmprandstate_mpc ();
 }