gmp 0.6.47 → 0.7.19

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a40972b493a89ea10856fa799609c7dccea84d13
+  data.tar.gz: 1614d5eb7cf7846add652665a32d1a92035b3843
+SHA512:
+  metadata.gz: d6500aca0dec138a7a83a6e4f6e483b5cc7b532aca8f02cf397f4f04eda9ffda3f08342d3e69ea62f94ff33a637062d6837736a3259a0103ef00047c198d83e8
+  data.tar.gz: 03d62dc2d10bd81a380b0413c168c4db1056564c6e2e5a573cf74fea14e3354f552884647222cf298f23f5ba77e646bfa4c0d358c5733f75daa51bec5582f444

data/CHANGELOG

@@ -1,3 +1,22 @@
+0.7.19
+  * GMP::Q.new can now accept a GMP::Z or Fixnum more intelligently, and can
+    accept a Float, and is tested better.
+  * GMP::F.new can now accept a rounding mode after the base, when a String is
+    passed in.
+  * Rakefile is much more robust with various dependencies.
+  * Yardoc documentation is less completely broken.
+  * GMP::F#** is now slightly more efficient when the argument is a Fixnum or
+    GMP::Z, and is now tested.
+  * Bigger error message when GMP can't be found. Fixes #4.
+  * Rearrange args for GMP::F#atan2, #agm, and #hypot; contributed by @timpeters
+  * Allow Float for args to GMP::F#atan2, #agm, and #hypot; contributed by
+    @timpeters
+  * Sanity checks for GMP::F#hypot
+  * Added new MPFR class methods: GMP::F.emin, GMP::F.emax, GMP::F.emin=,
+    GMP::F.emax=, GMP::F.emin_min, GMP::F.emin_max, GMP::F.emax_min, and
+    GMP::F.emax_max; also minimal tests, and documentation
+  * Added new MPFR constructor method: GMP::F.new_2exp, not really tested :)
+
 0.6.47
   * Fixed GMP::F#to_s when MPFR is not present. It now works, and accepts an
     optional base argument, just like GMP::F#to_s does when MPFR _is_ present.
@@ -9,7 +28,8 @@
     tests
   * Added tests for GMP::F#abs and GMP::F#neg
   * Added GMP::F.fac(n) (mpfr_fac_ui) and tests
-  * Added GMP::F.nan, GMP::F.inf, GMP::F.zero (MPFR >= 3.0.0), documentation, and simple tests
+  * Added GMP::F.nan, GMP::F.inf, GMP::F.zero (MPFR >= 3.0.0), documentation,
+    and simple tests
   * Added GMP::F#frexp, documentation, and tests
   * Fixed GMP::MPFR_RNDA
 

data/README.markdown

@@ -3,8 +3,9 @@ gmp
 
 [![Build Status](https://travis-ci.org/srawlins/gmp.png?branch=master)](https://travis-ci.org/srawlins/gmp)
 
-gmp is library providing Ruby bindings to GMP library. Here is the introduction
-paragraph at [their homepage](http://gmplib.org/#WHAT):
+gmp is a Rubygem providing Ruby bindings to the [GMP](https://gmplib.org/)
+library, and to the [MPFR](http://www.mpfr.org/) library (optional). Here is the
+introduction paragraph at [GMP's homepage](http://gmplib.org/#WHAT):
 
 > GMP is a free library for arbitrary precision arithmetic, operating on
 > signed integers, rational numbers, and floating point numbers. There is no
@@ -49,17 +50,20 @@ paragraph at [their homepage](http://gmplib.org/#WHAT):
 > contributions, meaning users can safely use GMP. To achieve this, we will ask
 > contributors to sign paperwork where they allow us to distribute their work."
 
-GMP 4.3.x and GMP 5.x are each supported against Ruby (MRI) 1.9.x, 2.0.0, and
-2.1.0. GMP 5.1.x is the only version of GMP that has been tested recently.
-Other Ruby platforms (such as Rubinius and JRuby) should be supported, but have not
-been tested recently.
+### Support
 
-### Previously
+* GMP 4.3.x and GMP 5.x are each supported against Ruby (MRI) 1.9.x, 2.0.0, and
+  2.1.0. GMP 5.1.x is the only version of GMP that has been tested recently.
+* MPFR 3.x is supported.
+* Other Ruby platforms (such as Rubinius and JRuby) should be supported, but
+  have not been tested recently.
+
+#### Previously
 
 Previously, on version 0.5.47, this gem was verified as functioning in the
 following combinations:
 
-<table border="1">
+<table border="0">
   <tr>
     <th>Platform</th>
     <th>Ruby</th>
@@ -163,7 +167,7 @@ as pi, are defined under class methods of GMP::F, listed below.
 * `GMP::GMP_BITS_PER_LIMB` The number of bits per limb
 * `GMP::GMP_NUMB_MAX` - The maximum value that can be stored in the number part of a limb
 
-if MPFR is available:
+If MPFR is available:
 * `GMP::MPFR_VERSION` - A string like "2.4.2"
 * `GMP::MPFR_PREC_MIN` - The minimum precision available
 * `GMP::MPFR_PREC_MAX` - The maximum precision available
@@ -196,18 +200,26 @@ Numbers are created by using `new()`. Constructors can take following arguments:
     GMP::Z.new(Bignum)
     GMP::Z.new(String)
     GMP::Q.new()
+    GMP::Q.new(Fixnum)
+    GMP::Q.new(GMP::Z)
     GMP::Q.new(GMP::Q)
     GMP::Q.new(String)
     GMP::Q.new(any GMP::Z initializer)
+    GMP::Q.new(Fixnum, Fixnum)
     GMP::Q.new(any GMP::Z initializer, any GMP::Z initializer)
     GMP::F.new()
     GMP::F.new(GMP::Z, precision=0, rounding_mode=default)
     GMP::F.new(GMP::Q, precision=0, rounding_mode=default)
     GMP::F.new(GMP::F, precision=0, rounding_mode=default)
     GMP::F.new(String, precision=0)
+    GMP::F.new(String, precision=0, base=10)
+    GMP::F.new(String, precision=0, base=10, rounding_mode=default)
     GMP::F.new(Fixnum, precision=0, rounding_mode=default)
     GMP::F.new(Bignum, precision=0, rounding_mode=default)
     GMP::F.new(Float,  precision=0, roundung_mode=default)
+    GMP::F.new_2exp(Fixnum, exp, precision=0, rounding_mode=default)
+    GMP::F.new_2exp(Bignum, exp, precision=0, rounding_mode=default)
+    GMP::F.new_2exp(GMP::Z, exp, precision=0, rounding_mode=default)
     GMP::RandState.new(\[algorithm\] \[, algorithm_args\])
 
 You can also call them as:
@@ -337,6 +349,14 @@ Methods
       const_pi                 returns pi
       const_euler              returns euler
       const_catalan            returns catalan
+      emin                     returns the smallest allowed exponent
+      emax                     returns the largest allowed exponent
+      emin=(exp)               sets the smallest allowed exponent
+      emax=(exp)               sets the largest allowed exponent
+      emin_min                 returns the smallest exponent allowed for GMP::F.emin=
+      emin_max                 returns the largest exponent allowed for GMP::F.emin=
+      emax_min                 returns the smallest exponent allowed for GMP::F.emax=
+      emax_max                 returns the largest exponent allowed for GMP::F.emax=
       mpfr_buildopt_tls_p      returns whether MPFR was built as thread safe
       mpfr_buildopt_decimal_p  returns whether MPFR was compiled with decimal
                                float support

data/ext/extconf.rb

@@ -43,6 +43,9 @@ if (begin; JRuby; rescue NameError; end) != nil
 end
 
 
+# This test is actually due to a Clang 3.3 shortcoming, included in OS X 10.9,
+# fixed in Clang 3.4:
+# http://llvm.org/releases/3.4/tools/clang/docs/ReleaseNotes.html#new-compiler-flags
 if try_compile('', '-O6')
   $CFLAGS += ' -Wall -W -O6 -g'
 else
@@ -52,6 +55,11 @@ end
 if ok
   create_makefile('gmp')
 else
+  $stderr.puts "*********************************************************************"
+  $stderr.puts "Your compiler was unable to link to GMP while installing the gmp gem."
+  $stderr.puts "Please install GMP before installing the gmp gem."
+  $stderr.puts "*********************************************************************"
+
   raise "Unable to build, correct above errors and rerun"
 end
 

data/ext/gmp.c

@@ -49,11 +49,11 @@ static VALUE r_gmpfsg_set_default_prec(VALUE klass, VALUE arg)
   (void)klass;
   if (FIXNUM_P(arg)) {
     if (FIX2NUM(arg) <= 0) {
-      rb_raise(rb_eRangeError, "prec must be positive");
+      rb_raise(rb_eRangeError, "precision must be positive");
     }
     mpf_set_default_prec (FIX2NUM(arg));
   } else {
-    rb_raise(rb_eTypeError, "prec must be FixNum");
+    rb_raise(rb_eTypeError, "precision must be Fixnum");
   }
   return Qnil;
 }
@@ -84,6 +84,8 @@ int get_base(VALUE base_val) {
   } else {
     rb_raise(rb_eTypeError, "Expected Fixnum or one of :bin, :oct, :dec, :hex");
   }
+
+  return 0;  /* should never get here */
 }
 
 VALUE r_gmpsg_sprintf2(VALUE klass, VALUE format, VALUE arg) {
@@ -116,7 +118,7 @@ VALUE r_gmpsg_sprintf2(VALUE klass, VALUE format, VALUE arg) {
 #ifdef MPFR
 mp_rnd_t r_get_rounding_mode(VALUE rnd)
 {
-  VALUE mode;
+  VALUE mode = 0;
   int max_rnd;
 
 #if MPFR_VERSION_MAJOR>2
@@ -126,12 +128,12 @@ mp_rnd_t r_get_rounding_mode(VALUE rnd)
 #endif
 
   if (GMPRND_P (rnd)) {
-    mode = rb_funcall (rnd, rb_intern("mode"), 0);
+    mode = rb_funcall (rnd, rb_intern ("mode"), 0);
     if (FIX2INT (mode) < 0 || FIX2INT (mode) > max_rnd) {
       rb_raise (rb_eRangeError, "rounding mode must be one of the rounding mode constants.");
     }
   } else {
-    rb_raise(rb_eTypeError, "rounding mode must be one of the rounding mode constants.");
+    rb_raise (rb_eTypeError, "rounding mode must be one of the rounding mode constants.");
   }
 
   switch (FIX2INT (mode)) {
@@ -197,8 +199,6 @@ void Init_gmp() {
   init_gmpq ();
   rb_define_method(cGMP_Q, "initialize", r_gmpq_initialize, -1);
   rb_define_method(cGMP_Q, "coerce", r_gmpq_coerce, 1);
-  rb_define_method(cGMP_Q, "num", r_gmpq_num, 0);
-  rb_define_method(cGMP_Q, "den", r_gmpq_den, 0);
 
   cGMP_F = rb_define_class_under (mGMP, "F", rb_cNumeric);
   init_gmpf ();

data/ext/gmpf.c

@@ -7,8 +7,8 @@
  *
  * GMP Multiple Precision floating point numbers.
  *
- * Instances of this class can store variables of the type mpf_t. This class
- * also contains many methods that act as the functions for mpf_t variables,
+ * Instances of this class can store variables of the type `mpf_t`. This class
+ * also contains many methods that act as the functions for `mpf_t` variables,
  * as well as a few methods that attempt to make this library more Ruby-ish.
  */
 
@@ -85,7 +85,7 @@ VALUE r_gmpfsg_new(int argc, VALUE *argv, VALUE klass)
   (void)klass;
 
   if (argc > 4)
-    rb_raise(rb_eArgError, "wrong # of arguments (%d for 0, 1 2, 3, or 4)", argc);
+    rb_raise(rb_eArgError, "wrong number of arguments (%d for 0, 1, 2, 3, or 4)", argc);
 
   mpf_make_struct (res, res_val);
   rb_obj_call_init(res, argc, argv);
@@ -118,18 +118,18 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
 
   arg = argv[0];
 
-  //argc >= 2 ==> argv[0] is value, argv[1] is prec
+  /* argc >= 2 ==> argv[0] is value, argv[1] is prec */
   if (argc >= 2) {
     if (FIXNUM_P(argv[1])) {
       if (FIX2INT(argv[1]) >= 0)
         prec = FIX2INT(argv[1]);
       else {
         r_mpf_init (self_val);
-        rb_raise(rb_eRangeError, "prec must be non-negative");
+        rb_raise(rb_eRangeError, "precision must be non-negative");
       }
     } else {
       r_mpf_init (self_val);
-      rb_raise(rb_eTypeError, "prec must be a Fixnum");
+      rb_raise(rb_eTypeError, "precision must be a Fixnum");
     }
   } else if (GMPF_P(arg)) {
     mpf_get_struct (arg, arg_val_f);
@@ -143,24 +143,24 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
   else
     mpfr_init2 (self_val, prec);
 
-  if (STRING_P(argv[0])) {
+  if (STRING_P (argv[0])) {
     if (argc >= 3) {
-      if (FIXNUM_P(argv[2])) {
-        if (FIX2INT(argv[2]) >= 2 && FIX2INT(argv[2]) <= 36)
-          base = FIX2INT(argv[2]);
-        else
-          rb_raise(rb_eRangeError, "base must be between 2 and 36");
-      }
-      else {
+      if (! FIXNUM_P (argv[2]))
         rb_raise(rb_eTypeError, "base must be a Fixnum");
-      }
-    }
 
-    if (argc == 4) {
-      // TODO: FIGURE IT OUT. ACCEPT A ROUNDING MODE!
+      if (FIX2INT (argv[2]) >= 2 && FIX2INT (argv[2]) <= 36)
+        base = FIX2INT (argv[2]);
+      else
+        rb_raise (rb_eRangeError, "base must be between 2 and 36");
+
+      if (argc == 4)
+        rnd_mode_val = r_get_rounding_mode (argv[3]);
+      else
+        rnd_mode_val = __gmp_default_rounding_mode;
     }
 
-    mpf_set_value2 (self_val, arg, base);
+
+    mpf_set_value2 (self_val, arg, base, rnd_mode_val);
     return Qnil;
   } else {  /* not STRING_P(argv[0]) */
     if (argc == 3)
@@ -188,7 +188,7 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
   } else {
     mpf_set_value (self_val, arg);
   }
-#endif
+#endif /* MPFR */
 
   return Qnil;
 }
@@ -261,23 +261,81 @@ void mpfr_set_value(MP_FLOAT *self_val, VALUE arg, mp_rnd_t rnd_mode_val)
   }
 }
 
-void mpf_set_value2(MP_FLOAT *self_val, VALUE arg, int base)
+void mpf_set_value2(MP_FLOAT *self_val, VALUE arg, int base, mp_rnd_t rnd_mode_val)
 {
   int result;
 
-  /* TODO use rnd_mode_val */
-  result = mpfr_set_str (self_val, StringValuePtr (arg), base, __gmp_default_rounding_mode);
+  result = mpfr_set_str (self_val, StringValuePtr (arg), base, rnd_mode_val);
 
   if (result == -1) {
     rb_raise (rb_eRuntimeError, "Badly formatted string");
   }
 }
 
+#if MPFR_VERSION_MAJOR > 2
+VALUE r_gmpfsg_new_2exp(int argc, VALUE *argv, VALUE klass)
+{
+  MP_FLOAT *res;
+  MP_INT *arg_z;
+  VALUE res_val, arg_val, exp_val, prec_val, rnd_mode_val;
+  mp_rnd_t rnd_mode;
+  (void)klass;
+
+  rb_scan_args (argc, argv, "22", &arg_val, &exp_val, &prec_val, &rnd_mode_val);
+  mpf_make_struct (res_val, res);
+
+  if (!FIXNUM_P (exp_val)) {
+    mpfr_init (res);
+    rb_raise(rb_eTypeError, "exp must be a Fixnum");
+  }
+
+  if (NIL_P (prec_val))
+    mpfr_init (res);
+  else if (FIXNUM_P (prec_val)) {
+    if (FIX2INT (prec_val) >= 0) {
+      mpfr_init2 (res, FIX2INT (prec_val));
+    } else {
+      mpfr_init (res);
+      rb_raise(rb_eRangeError, "precision must be non-negative");
+    }
+  } else {
+    mpfr_init (res);
+    rb_raise(rb_eTypeError, "precision must be a Fixnum");
+  }
+
+  if (NIL_P (rnd_mode_val))
+    rnd_mode = __gmp_default_rounding_mode;
+  else
+    rnd_mode = r_get_rounding_mode (rnd_mode_val);
+
+  if (GMPZ_P (arg_val)) {
+    mpz_get_struct (arg_val, arg_z);
+    mpfr_set_z_2exp (res, arg_z, FIX2NUM (exp_val), rnd_mode);
+  } else if (FIXNUM_P (arg_val)) {
+    mpfr_set_si_2exp (res, FIX2NUM (arg_val), FIX2NUM (exp_val), rnd_mode);
+  } else if (BIGNUM_P (arg_val)) {
+#if 1 /* GMP3 code */
+    mpz_temp_from_bignum (arg_z, arg_val);
+    mpfr_set_z_2exp (res, arg_z, FIX2NUM (exp_val), rnd_mode);
+    mpz_temp_free (arg_z);
+#endif /* GMP3 code */
+  } else {
+    rb_raise (rb_eTypeError, "Don't know how to convert %s into GMP::F", rb_class2name (rb_class_of (arg_val)));
+    typeerror_as (ZXB, "value");
+  }
+
+  return res_val;
+}
+#endif /* MPFR_VERSION_MAJOR > 2 */
+
 /*
+ * Document-method: nan
  * call-seq:
  *   GMP::F.nan
  *
- * NaN, an instance of GMP::F
+ * `NaN`, an instance of GMP::F
+ *
+ * @since 0.6.47
  */
 VALUE r_gmpfsg_nan(VALUE klass)
 {
@@ -292,18 +350,21 @@ VALUE r_gmpfsg_nan(VALUE klass)
 }
 
 /*
+ * Document-method: inf
  * call-seq:
  *   GMP::F.inf
  *   GMP::F.inf(sign)
  *
- * Inf (positive infinity), an instance of GMP::F, or -Inf (negative infinity),
- * if a negative Fixnum _sign_ is passed
+ * `Inf` (positive infinity), an instance of GMP::F, or `-Inf` (negative
+ * infinity), if a negative Fixnum _sign_ is passed
+ *
+ * @since 0.6.47
  */
 VALUE r_gmpfsg_inf(int argc, VALUE *argv, VALUE klass)
 {
   MP_FLOAT *res;
   VALUE sign_val, res_val;
-  int sign;
+  int sign = 0;
   (void)klass;
 
   rb_scan_args (argc, argv, "01", &sign_val);
@@ -319,17 +380,20 @@ VALUE r_gmpfsg_inf(int argc, VALUE *argv, VALUE klass)
 
 #if MPFR_VERSION_MAJOR > 2
 /*
+ * Document-method: zero
  * call-seq:
  *   GMP::F.zero
  *   GMP::F.zero(sign)
  *
  * zero or negative zero, an instance of GMP::F, depending on _sign_, a Fixnum
+ *
+ * @since 0.6.47
  */
 VALUE r_gmpfsg_zero(int argc, VALUE *argv, VALUE klass)
 {
   MP_FLOAT *res;
   VALUE sign_val, res_val;
-  int sign;
+  int sign = 0;
   (void)klass;
 
   rb_scan_args (argc, argv, "01", &sign_val);
@@ -349,7 +413,7 @@ VALUE r_gmpfsg_zero(int argc, VALUE *argv, VALUE klass)
  * call-seq:
  *   GMP::F(arg)
  *
- * A convenience method for +GMP::F.new(arg)+.
+ * A convenience method for GMP::F.new(arg).
  */
 VALUE r_gmpmod_f(int argc, VALUE *argv, VALUE module)
 {
@@ -363,6 +427,7 @@ VALUE r_gmpmod_f(int argc, VALUE *argv, VALUE module)
  **********************************************************************/
 
 /*
+ * Document-method: to_d
  * call-seq:
  *   x.to_d
  *
@@ -377,6 +442,7 @@ VALUE r_gmpf_to_d(VALUE self)
 }
 
 /*
+ * Document-method: to_s
  * call-seq:
  *   x.to_s(base = 10)
  *
@@ -440,10 +506,12 @@ VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self_val)
 
 #ifndef MPFR
 /*
+ * Document-method: +
  * call-seq:
  *   x + y
  *
  * Returns the sum of _x_ and _y_. _y_ must be an instance of:
+ *
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -480,7 +548,7 @@ VALUE r_gmpf_add(VALUE self, VALUE arg)
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_d (res_val, NUM2DBL(arg));
     mpf_add (res_val, res_val, self_val);
-  } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
+  } else if (FIXNUM_P(arg)) { /* TODO: _ui with sign control instead */
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_si (res_val, FIX2NUM(arg));
     mpf_add (res_val, res_val, self_val);
@@ -498,10 +566,12 @@ VALUE r_gmpf_add(VALUE self, VALUE arg)
 }
 #else
 /*
+ * Document-method: +
  * call-seq:
  *   x + y
  *
  * Returns the sum of _x_ and _y_. _y_ must be an instance of:
+ *
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -564,10 +634,12 @@ DEFUN_F_ZQXFBD2F(mul)
 #endif
 
 /*
+ * Document-method: -
  * call-seq:
  *   x - y
  *
  * Subtracts _y_ from _x_. _y_ must be an instance of:
+ *
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -580,7 +652,7 @@ VALUE r_gmpf_sub(VALUE self, VALUE arg)
   MP_FLOAT *self_val, *res_val, *arg_val_f;
   MP_RAT *arg_val_q;
   MP_INT *arg_val_z;
-  VALUE res;
+  VALUE res = 0;
   mpfr_prec_t prec;
 
   mpf_get_struct_prec (self, self_val, prec);
@@ -604,7 +676,7 @@ VALUE r_gmpf_sub(VALUE self, VALUE arg)
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_d(res_val, NUM2DBL(arg));
     mpf_sub(res_val, self_val, res_val);
-  } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
+  } else if (FIXNUM_P(arg)) { /* TODO: _ui with sign control instead ? */
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_si(res_val, FIX2NUM(arg));
     mpf_sub(res_val, self_val, res_val);
@@ -622,10 +694,12 @@ VALUE r_gmpf_sub(VALUE self, VALUE arg)
 }
 
 /*
+ * Document-method: *
  * call-seq:
  *   x * y
  *
- * Returns the product of _x_ and _y_. _y_ can be
+ * Returns the product of _x_ and _y_. _y_ can be one of:
+ *
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -638,7 +712,7 @@ VALUE r_gmpf_mul(VALUE self, VALUE arg)
   MP_FLOAT *self_val, *res_val, *arg_val_f;
   MP_RAT *arg_val_q;
   MP_INT *arg_val_z;
-  VALUE res;
+  VALUE res = 0;
   mpfr_prec_t prec;
 
   mpf_get_struct_prec (self, self_val, prec);
@@ -662,7 +736,7 @@ VALUE r_gmpf_mul(VALUE self, VALUE arg)
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_d(res_val, NUM2DBL(arg));
     mpf_mul(res_val, self_val, res_val);
-  } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
+  } else if (FIXNUM_P(arg)) { /* _ui with sign control instead ? */
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_si(res_val, FIX2NUM(arg));
     mpf_mul(res_val, self_val, res_val);
@@ -680,17 +754,19 @@ VALUE r_gmpf_mul(VALUE self, VALUE arg)
 }
 
 /*
+ * Document-method: **
  * call-seq:
  *   x ** y
  *
  * Returns _x_ raised to the _y_ power. _y_ must be
+ *
  * * an instance of Fixnum or Bignum
  * * non-negative
  */
 VALUE r_gmpf_pow(VALUE self, VALUE arg)
 {
   MP_FLOAT *self_val, *res_val;
-  VALUE res;
+  VALUE res = 0;
 
   //unsigned long prec;
   mpfr_prec_t prec;
@@ -712,10 +788,12 @@ VALUE r_gmpf_pow(VALUE self, VALUE arg)
 }
 
 /*
+ * Document-method: /
  * call-seq:
  *   x / y
  *
  * Divides _x_ by _y_. _y_ can be
+ *
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -728,7 +806,7 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
   MP_FLOAT *self_val, *res_val, *arg_val_f;
   MP_RAT *arg_val_q;
   MP_INT *arg_val_z;
-  VALUE res;
+  VALUE res = 0;
   mpfr_prec_t prec;
 
   mpf_get_struct_prec (self, self_val, prec);
@@ -752,7 +830,7 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_d(res_val, NUM2DBL(arg));
     mpf_div(res_val, self_val, res_val);
-  } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
+  } else if (FIXNUM_P(arg)) { /* TODO: _ui with sign control instead */
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_si(res_val, FIX2NUM(arg));
     mpf_div(res_val, self_val, res_val);
@@ -760,7 +838,7 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
     mpz_temp_from_bignum(arg_val_z, arg);
     mpf_make_struct_init(res, res_val, prec);
     mpf_set_z(res_val, arg_val_z);
-    mpf_div(res_val, self_val, res_val);	
+    mpf_div(res_val, self_val, res_val);
     mpz_temp_free(arg_val_z);
   } else {
     typeerror(ZQFXBD);
@@ -771,10 +849,12 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
 
 #ifdef MPFR
 /*
+ * Document-method: **
  * call-seq:
  *   float ** other
  *
- * Returns _x_ raised to the _y_ power. _y_ must be an instance of
+ * Returns _x_ raised to the _y_ power. _y_ must be an instance of:
+ *
  * * Fixnum
  * * Bignum
  * * Float
@@ -825,7 +905,6 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
 
 /*
  * Document-method: neg
- *
  * call-seq:
  *   x.neg
  *   -x
@@ -834,16 +913,15 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
  */
 /*
  * Document-method: neg!
- *
  * call-seq:
  *   x.neg!
  *
  * Sets _x_ to -_x_.
  */
 DEFUN_FLOAT2FLOAT(neg,mpf_neg)
+
 /*
  * Document-method: abs
- *
  * call-seq:
  *   x.abs
  *
@@ -851,7 +929,6 @@ DEFUN_FLOAT2FLOAT(neg,mpf_neg)
  */
 /*
  * Document-method: abs!
- *
  * call-seq:
  *   x.abs!
  *
@@ -889,19 +966,19 @@ int mpf_cmp_value(MP_FLOAT *self_val, VALUE arg)
  * what does really "equal" mean ? it's not obvious
  * Is this a note that I, srawlins, put in here? It is not obvious to me...
  */
-VALUE r_gmpf_eq(VALUE self, VALUE arg)
+VALUE r_gmpf_eq(VALUE self_val, VALUE arg_val)
 {
-  MP_FLOAT *self_val;
-  mpf_get_struct (self,self_val);
-  return (mpf_cmp_value(self_val, arg) == 0) ? Qtrue : Qfalse;
+  MP_FLOAT *self;
+  mpf_get_struct (self_val, self);
+  return (mpf_cmp_value (self, arg_val) == 0) ? Qtrue : Qfalse;
 }
 
-VALUE r_gmpf_cmp(VALUE self, VALUE arg)
+VALUE r_gmpf_cmp(VALUE self_val, VALUE arg_val)
 {
-  MP_FLOAT *self_val;
+  MP_FLOAT *self;
   int res;
-  mpf_get_struct (self, self_val);
-  res = mpf_cmp_value (self_val, arg);
+  mpf_get_struct (self_val, self);
+  res = mpf_cmp_value (self, arg_val);
   if (res > 0)
     return INT2FIX(1);
   else if (res == 0)
@@ -916,25 +993,29 @@ DEFUN_FLOAT_CMP(gt,>)
 DEFUN_FLOAT_CMP(ge,>=)
 
 /*
+ * Document-method: sgn
  * call-seq:
  *   x.sgn
  *
  * Returns +1 if _x_ > 0, 0 if _x_ == 0, and -1 if _x_ < 0.
  */
-VALUE r_gmpf_sgn(VALUE self)
+VALUE r_gmpf_sgn(VALUE self_val)
 {
-  MP_FLOAT *self_val;
-  mpf_get_struct (self, self_val);
-  return INT2FIX (mpf_sgn (self_val));
+  MP_FLOAT *self;
+  mpf_get_struct (self_val, self);
+  return INT2FIX (mpf_sgn (self));
 }
 
 #ifdef MPFR
 
 /*
+ * Document-method: lessgreater?
  * call-seq:
  *   x.lessgreater?(y)
  *
- * Return true if _x_ < _y_ or _x_ > _y_; false otherwise
+ * Return true if _x_ < _y_ or _x_ > _y_, false otherwise
+ *
+ * @since 0.6.47
  */
 VALUE r_gmpfr_lessgreater_p(VALUE self_val, VALUE arg_val)
 {
@@ -949,10 +1030,13 @@ VALUE r_gmpfr_lessgreater_p(VALUE self_val, VALUE arg_val)
 }
 
 /*
+ * Document-method: unordered?
  * call-seq:
  *   x.unordered?(y)
  *
- * Return true if _x_ or _y_ is a NaN; false otherwise
+ * Return true if _x_ or _y_ is a `NaN`, false otherwise
+ *
+ * @since 0.6.47
  */
 VALUE r_gmpfr_unordered_p(VALUE self_val, VALUE arg_val)
 {
@@ -980,26 +1064,26 @@ DEFUN_FLOAT2FLOAT(ceil,mpf_ceil)
 
 #ifdef MPFR
 
-#define MPFR_SINGLE_FUNCTION(name)                             \
-VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)        \
-{                                                              \
-  MP_FLOAT *self_val, *res_val;                                \
-  VALUE rnd_mode, res_prec, res;                               \
-  mpfr_prec_t prec, res_prec_value;                            \
-  mp_rnd_t rnd_mode_val;                                       \
-                                                               \
-  mpf_get_struct_prec (self, self_val, prec);                  \
-                                                               \
-  rb_scan_args (argc, argv, "02", &rnd_mode, &res_prec);       \
-  if (NIL_P (rnd_mode)) { rnd_mode_val = __gmp_default_rounding_mode; }  \
-  else { rnd_mode_val = r_get_rounding_mode(rnd_mode); }       \
-  if (NIL_P (res_prec)) { res_prec_value = prec; }             \
-  /* TODO test type */                                         \
-  else { res_prec_value = FIX2INT (res_prec); }                \
-  mpf_make_struct_init (res, res_val, res_prec_value);         \
-  mpfr_##name (res_val, self_val, rnd_mode_val);               \
-                                                               \
-  return res;                                                  \
+#define MPFR_SINGLE_FUNCTION(name)                                       \
+VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self_val)              \
+{                                                                        \
+  MP_FLOAT *self, *res;                                                  \
+  VALUE rnd_mode_val, res_prec_val, res_val;                             \
+  mpfr_prec_t prec, res_prec;                                            \
+  mp_rnd_t rnd_mode;                                                     \
+                                                                         \
+  mpf_get_struct_prec (self_val, self, prec);                            \
+                                                                         \
+  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_get_rounding_mode(rnd_mode_val); }                 \
+  if (NIL_P (res_prec_val)) { res_prec = prec; }                         \
+  else if (FIXNUM_P (res_prec_val)) { res_prec = FIX2INT (res_prec_val); } \
+  else { typeerror_as (X, "precision"); }                                \
+  mpf_make_struct_init (res_val, res, res_prec);                         \
+  mpfr_##name (res, self, rnd_mode);                                     \
+                                                                         \
+  return res_val;                                                        \
 }
 
 #define MPFR_DOUBLE_FUNCTION(name)                                   \
@@ -1061,15 +1145,24 @@ VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)                    \
   rb_scan_args (argc, argv, "12", &arg1, &rnd_mode, &res_prec);            \
                                                                            \
   mpf_get_struct_prec (self, self_val, prec);                              \
-  if (!GMPF_P (arg1)) { typeerror(FD); }                                   \
-  mpf_get_struct_prec (arg1, arg1_val, arg1_prec);                         \
+  if (GMPF_P (arg1)) {                                                     \
+    mpf_get_struct_prec (arg1, arg1_val, arg1_prec);                       \
+  } else if (FLOAT_P (arg1)) {                                             \
+    mpf_temp_init(arg1_val, mpf_get_prec (self_val));                      \
+    mpfr_set_d (arg1_val, NUM2DBL (arg1), __gmp_default_rounding_mode);    \
+  } else {                                                                 \
+    typeerror (FD);                                                        \
+  }                                                                        \
   if (NIL_P (rnd_mode)) { rnd_mode_val = __gmp_default_rounding_mode; }    \
   else { rnd_mode_val = r_get_rounding_mode(rnd_mode); }                   \
   if (NIL_P (res_prec)) { res_prec_value = prec; }                         \
   /* TODO test type */                                                     \
   else { res_prec_value = FIX2INT (res_prec); }                            \
   mpf_make_struct_init (res, res_val, res_prec_value);                     \
-  mpfr_##name (res_val, arg1_val, self_val, rnd_mode_val);                 \
+  mpfr_##name (res_val, self_val, arg1_val, rnd_mode_val);                 \
+  if (FLOAT_P (arg1)) {                                                    \
+    mpf_temp_free(arg1_val);                                               \
+  }                                                                        \
                                                                            \
   return res;                                                              \
 }
@@ -1094,7 +1187,7 @@ VALUE r_gmpfrsg_##name(int argc, VALUE *argv, VALUE self)    \
   VALUE res;                                                 \
   VALUE rnd_mode, prec;                                      \
   mp_rnd_t rnd_mode_val;                                     \
-  mpfr_prec_t prec_val;                                      \
+  mpfr_prec_t prec_val = 0;                                  \
   (void)self;                                                \
                                                              \
   rb_scan_args (argc, argv, "02", &rnd_mode, &prec);         \
@@ -1103,7 +1196,7 @@ VALUE r_gmpfrsg_##name(int argc, VALUE *argv, VALUE self)    \
   else { rnd_mode_val = r_get_rounding_mode (rnd_mode); }    \
   if (NIL_P (prec)) { prec_val = mpfr_get_default_prec(); }  \
   else if (FIXNUM_P (prec)) { prec_val = FIX2INT (prec); }   \
-  else { typeerror_as (Z, "prec"); }                         \
+  else { typeerror_as (X, "precision"); }                    \
   mpf_make_struct_init (res, res_val, prec_val);             \
   mpfr_##name (res_val, rnd_mode_val);                       \
                                                              \
@@ -1111,14 +1204,17 @@ VALUE r_gmpfrsg_##name(int argc, VALUE *argv, VALUE self)    \
 }
 
 /*
+ * Document-method: frexp
  * call-seq:
  *   exp, y = x.frexp(rnd_mode = nil, prec = nil)
  *
- * Set _exp_ and _y_ such that
- * 0.5 <= _abs(y)_ < 1 and _y_ times 2 raised to _exp_ equals _x_ rounded to _prec_, or the precision
- * of _x_, using the given rounding mode. If _x_ is zero, then _y_ is set to a zero
- * of the same sign and _exp_ is set to 0. If _x_ is NaN or an infinity, then _y_ is
- * set to the same value and _exp_ is undefined.
+ * Set _exp_ and _y_ such that 0.5 <= _abs(y)_ < 1 and _y_ times 2 raised to
+ * _exp_ equals _x_ rounded to _prec_, or the precision of _x_, using the given
+ * rounding mode. If _x_ is zero, then _y_ is set to a zero of the same sign
+ * and _exp_ is set to 0. If _x_ is `NaN` or an infinity, then _y_ is set to
+ * the same value and _exp_ is undefined.
+ *
+ * @since 0.6.47
  */
 VALUE r_gmpfr_frexp(int argc, VALUE *argv, VALUE self_val)
 {
@@ -1142,22 +1238,212 @@ VALUE r_gmpfr_frexp(int argc, VALUE *argv, VALUE self_val)
   return rb_assoc_new(exp_val, res_val);
 }
 
+/*
+ * Document-method: sqrt
+ * call-seq:
+ *   x.sqrt
+ *   x.sqrt(rounding_mode)
+ *   x.sqrt(rounding_mode, precision)
+ *
+ * Calculate the square root of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(sqrt)
+
+/*
+ * Document-method: rec_sqrt
+ * call-seq:
+ *   x.rec_sqrt
+ *   x.rec_sqrt(rounding_mode)
+ *   x.rec_sqrt(rounding_mode, precision)
+ *
+ * Calculate the reciprocal square root of _x_, rounding according to
+ * `rounding_mode`. The resultant GMP::F float has the same precision that _x_
+ * has, if `precision` was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(rec_sqrt)
+
+/*
+ * Document-method: cbrt
+ * call-seq:
+ *   x.cbrt
+ *   x.cbrt(rounding_mode)
+ *   x.cbrt(rounding_mode, precision)
+ *
+ * Calculate the cubic root of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(cbrt)
 
+/*
+ * Document-method: log
+ * call-seq:
+ *   x.log
+ *   x.log(rounding_mode)
+ *   x.log(rounding_mode, precision)
+ *
+ * Calculate the natural logarithm of _x_, rounding according to
+ * `rounding_mode`. The resultant GMP::F float has the same precision that _x_
+ * has, if `precision` was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(log)
+
+/*
+ * Document-method: log2
+ * call-seq:
+ *   x.log2
+ *   x.log2(rounding_mode)
+ *   x.log2(rounding_mode, precision)
+ *
+ * Calculate the logarithm base 2 of _x_, rounding according to
+ * `rounding_mode`. The resultant GMP::F float has the same precision that _x_
+ * has, if `precision` was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(log2)
+
+/*
+ * Document-method: log10
+ * call-seq:
+ *   x.log10
+ *   x.log10(rounding_mode)
+ *   x.log10(rounding_mode, precision)
+ *
+ * Calculate the logarithm base 10 of _x_, rounding according to
+ * `rounding_mode`. The resultant GMP::F float has the same precision that _x_
+ * has, if `precision` was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(log10)
+
+/*
+ * Document-method: exp
+ * call-seq:
+ *   x.exp
+ *   x.exp(rounding_mode)
+ *   x.exp(rounding_mode, precision)
+ *
+ * Calculate the exponential of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(exp)
+
+/*
+ * Document-method: exp2
+ * call-seq:
+ *   x.exp2
+ *   x.exp2(rounding_mode)
+ *   x.exp2(rounding_mode, precision)
+ *
+ * Calculate the 2 power of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(exp2)
+
+/*
+ * Document-method: exp10
+ * call-seq:
+ *   x.exp10
+ *   x.exp10(rounding_mode)
+ *   x.exp10(rounding_mode, precision)
+ *
+ * Calculate the 10 power of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(exp10)
+
+/*
+ * Document-method: cos
+ * call-seq:
+ *   x.cos
+ *   x.cos(rounding_mode)
+ *   x.cos(rounding_mode, precision)
+ *
+ * Calculate the cosine of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(cos)
+
+/*
+ * Document-method: sin
+ * call-seq:
+ *   x.sin
+ *   x.sin(rounding_mode)
+ *   x.sin(rounding_mode, precision)
+ *
+ * Calculate the sine of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(sin)
+
+/*
+ * Document-method: tan
+ * call-seq:
+ *   x.tan
+ *   x.tan(rounding_mode)
+ *   x.tan(rounding_mode, precision)
+ *
+ * Calculate the tangent of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(tan)
+
+/*
+ * Document-method: sin_cos
+ * call-seq:
+ *   x.sin_cos
+ *   x.sin_cos(rounding_mode)
+ *   x.sin_cos(rounding_mode, precision)
+ *
+ * Simultaneously calculate the sine and cosine of _x_, rounding according to
+ * `rounding_mode`, returning both numbers. The resultant GMP::F floats have
+ * the same precision that _x_ has, if `precision` was not passed in.
+ */
 MPFR_DOUBLE_FUNCTION(sin_cos)
+
+/*
+ * Document-method: secant
+ * call-seq:
+ *   x.secant
+ *   x.secant(rounding_mode)
+ *   x.secant(rounding_mode, precision)
+ *
+ * Calculate the secant of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(sec)
+
+/*
+ * Document-method: csc
+ * call-seq:
+ *   x.csc
+ *   x.csc(rounding_mode)
+ *   x.csc(rounding_mode, precision)
+ *
+ * Calculate the cosecant of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(csc)
+
+/*
+ * Document-method: cot
+ * call-seq:
+ *   x.cot
+ *   x.cot(rounding_mode)
+ *   x.cot(rounding_mode, precision)
+ *
+ * Calculate the cotangent of _x_, rounding according to `rounding_mode`. The
+ * resultant GMP::F float has the same precision that _x_ has, if `precision`
+ * was not passed in.
+ */
 MPFR_SINGLE_FUNCTION(cot)
 MPFR_SINGLE_FUNCTION(acos)
 MPFR_SINGLE_FUNCTION(asin)
@@ -1206,6 +1492,8 @@ MPFR_SINGLE_MPF_FUNCTION(hypot)
  * Creates a new GMP::F float, equal to the factorial of n, which must be a
  * Fixnum. Optionally pass a rounding mode, and precision for the resultant
  * GMP::F.
+ *
+ * @since 0.6.47
  */
 VALUE r_gmpfrsg_fac(int argc, VALUE *argv, VALUE self_val)
 {
@@ -1214,7 +1502,7 @@ VALUE r_gmpfrsg_fac(int argc, VALUE *argv, VALUE self_val)
   VALUE rnd_mode_val, prec_val;
   mp_rnd_t rnd_mode;
   mpfr_prec_t prec;
-  unsigned long int arg;
+  unsigned long int arg = 0;
   (void)self_val;
 
   rb_scan_args (argc, argv, "12", &arg_val, &rnd_mode_val, &prec_val);
@@ -1279,54 +1567,62 @@ MPFR_SINGLE_BOOLEAN_FUNCTION(zero_p)
 MPFR_SINGLE_BOOLEAN_FUNCTION(regular_p)
 #endif
 
-static VALUE r_gmpfr_pow(VALUE self, VALUE arg)
+static VALUE r_gmpfr_pow(VALUE self_val, VALUE arg_val)
 {
-  MP_FLOAT *self_val, *res_val, *arg_val_f;
-  MP_RAT *arg_val_q;
-  MP_INT *arg_val_z;
+  MP_FLOAT *self, *res, *arg_f;
+  MP_RAT *arg_q;
+  MP_INT *arg_z;
   mpfr_prec_t prec;
-  VALUE res;
+  VALUE res_val;
 
-  mpf_get_struct_prec(self, self_val, prec);
+  mpf_get_struct_prec (self_val, self, prec);
 
-  if (GMPF_P(arg)) {
-    mpf_get_struct(arg, arg_val_f);
-    prec_max(prec, arg_val_f);
-    mpf_make_struct_init(res, res_val, prec);
-    mpfr_pow(res_val, self_val, arg_val_f, __gmp_default_rounding_mode);
+  if (GMPF_P (arg_val)) {
+    mpf_get_struct (arg_val, arg_f);
+    prec_max (prec, arg_f);
+    mpf_make_struct_init (res_val, res, prec);
+    mpfr_pow (res, self, arg_f, __gmp_default_rounding_mode);
   } else {
-    mpf_make_struct_init(res, res_val, prec);
-
-    if (GMPZ_P(arg)) {
-      mpz_get_struct(arg, arg_val_z);
-      mpf_set_z(res_val, arg_val_z);
-      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
-    } else if (GMPQ_P(arg)) {
-      mpq_get_struct(arg, arg_val_q);
-      mpf_set_q(res_val, arg_val_q);
-      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
-    } else if (FLOAT_P(arg)) {
-      mpf_set_d(res_val, NUM2DBL(arg));
-      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
-    } else if (FIXNUM_P(arg)) {
-      mpfr_pow_si(res_val, self_val, FIX2INT(arg), __gmp_default_rounding_mode);
-    } else if (BIGNUM_P(arg)) {
-      mpz_temp_from_bignum(arg_val_z, arg);
-      mpf_set_z(res_val, arg_val_z);
-      mpz_temp_free(arg_val_z);
-      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    mpf_make_struct_init (res_val, res, prec);
+
+    if (GMPZ_P (arg_val)) {
+      mpz_get_struct (arg_val, arg_z);
+      mpfr_pow_z (res, self, arg_z, __gmp_default_rounding_mode);
+    } else if (GMPQ_P (arg_val)) {
+      mpq_get_struct (arg_val, arg_q);
+      mpf_set_q (res, arg_q);
+      mpfr_pow (res, self, res, __gmp_default_rounding_mode);
+    } else if (FLOAT_P (arg_val)) {
+      mpf_set_d (res, NUM2DBL (arg_val));
+      mpfr_pow (res, self, res, __gmp_default_rounding_mode);
+    } else if (FIXNUM_P (arg_val)) {
+      if (FIX2NUM (arg_val) >= 0)
+        mpfr_pow_ui (res, self, FIX2NUM (arg_val), __gmp_default_rounding_mode);
+      else
+        mpfr_pow_si (res, self, FIX2NUM (arg_val), __gmp_default_rounding_mode);
+    } else if (BIGNUM_P (arg_val)) {
+      mpz_temp_from_bignum (arg_z, arg_val);
+      mpf_set_z (res, arg_z);
+      mpz_temp_free (arg_z);
+      mpfr_pow (res, self, res, __gmp_default_rounding_mode);
     } else {
-      typeerror(ZQFXBD);
+      typeerror (ZQFXBD);
     }
   }
 
-  return res;
+  return res_val;
 }
 
 /**********************************************************************
  *    Rounding Related Functions                                      *
  **********************************************************************/
 
+/*
+ * call-seq:
+ *   GMP::F.default_rounding_mode
+ *
+ * Get the default rounding mode.
+ */
 VALUE r_gmpfsg_get_default_rounding_mode(VALUE klass)
 {
   const char *rounding_string_val;
@@ -1340,17 +1636,25 @@ VALUE r_gmpfsg_get_default_rounding_mode(VALUE klass)
   }
 }
 
+/*
+ * call-seq:
+ *   GMP::F.default_rounding_mode=(rnd)
+ *
+ * Set the default rounding mode to _rnd_. The default rounding mode is to
+ * nearest initially.
+ */
 VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
 {
-  VALUE mode;
+  VALUE mode = 0;
   (void)klass;
-  if (GMPRND_P(arg)) {
+
+  if (GMPRND_P (arg)) {
     mode = rb_funcall (arg, rb_intern("mode"), 0);
-    if (FIX2INT(mode) < 0 || FIX2INT(mode) > 3) {
-      rb_raise(rb_eRangeError, "rounding mode must be one of the rounding mode constants.");
+    if (FIX2INT (mode) < 0 || FIX2INT (mode) > 3) {
+      rb_raise (rb_eRangeError, "rounding mode must be one of the rounding mode constants.");
     }
   } else {
-    rb_raise(rb_eTypeError, "rounding mode must be one of the rounding mode constants.");
+    rb_raise (rb_eTypeError, "rounding mode must be one of the rounding mode constants.");
   }
 
   switch (FIX2INT(mode)) {
@@ -1374,18 +1678,15 @@ VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
 VALUE r_gmpf_can_round(VALUE self, VALUE err, VALUE rnd1, VALUE rnd2, VALUE prec)
 {
   MP_FLOAT *self_val;
-  mp_exp_t err_val;
+  mp_exp_t err_val = 0;
   mpfr_rnd_t rnd1_val, rnd2_val;
   mpfr_prec_t prec_val;
 
-  mpf_get_struct(self, self_val);
-  if (FIXNUM_P(err)) {
-    err_val = FIX2INT(err);
-  } else {
-    typeerror_as(X, "err");
-  }
-  rnd1_val = r_get_rounding_mode(rnd1);
-  rnd2_val = r_get_rounding_mode(rnd2);
+  mpf_get_struct (self, self_val);
+  if (FIXNUM_P (err)) { err_val = FIX2INT (err); }
+  else { typeerror_as (X, "err"); }
+  rnd1_val = r_get_rounding_mode (rnd1);
+  rnd2_val = r_get_rounding_mode (rnd2);
   prec_val = FIX2INT (prec);
 
   if (mpfr_can_round (self_val, err_val, rnd1_val, rnd2_val, prec_val))
@@ -1396,28 +1697,53 @@ VALUE r_gmpf_can_round(VALUE self, VALUE err, VALUE rnd1, VALUE rnd2, VALUE prec
 
 
 /**********************************************************************
- *    Rounding Related Functions                                      *
+ *    _unsorted_                                                      *
  **********************************************************************/
 
+/*
+ * call-seq:
+ *   GMP::F.mpfr_buildopt_tls_p
+ *
+ * Return a non-zero value if MPFR was compiled as thread safe using
+ * compiler-level Thread Local Storage (that is, MPFR was built with the
+ * --enable-thread-safe configure option, see INSTALL file), return zero
+ *  otherwise.
+ */
 VALUE r_gmpfsg_mpfr_buildopt_tls_p(VALUE klass)
 {
   (void)klass;
   return INT2FIX (mpfr_buildopt_tls_p());
 }
 
+/*
+ * call-seq:
+ *   GMP::F.mpfr_buildopt_decimal_p
+ *
+ * Return a non-zero value if MPFR was compiled with decimal float support
+ * (that is, MPFR was built with the --enable-decimal-float configure option),
+ * return zero otherwise.
+ */
 VALUE r_gmpfsg_mpfr_buildopt_decimal_p(VALUE klass)
 {
   (void)klass;
   return INT2FIX (mpfr_buildopt_decimal_p());
 }
 
-#endif
+#endif  /* MPFR */
 
 
 /**********************************************************************
  *    _unsorted_                                                      *
  **********************************************************************/
 
+/*
+ * Document-method: prec
+ * call-seq:
+ *   x.prec
+ *
+ * Return the precision of _x_, i.e. the number of bits used to store its
+ * significand.
+ */
 VALUE r_gmpf_get_prec(VALUE self)
 {
   MP_FLOAT *self_val;
@@ -1425,6 +1751,16 @@ VALUE r_gmpf_get_prec(VALUE self)
   return INT2NUM (mpf_get_prec (self_val));
 }
 
+/*
+ * Document-method: prec=
+ * call-seq:
+ *   x.prec=(p)
+ *
+ * Reset the precision of _x_ to be exactly _p_ bits, and set its value to
+ * NaN. The previous value stored in _x_ is lost.
+ * The precision prec can be any integer between
+ * `MPFR_PREC_MIN` and `MPFR_PREC_MAX`.
+ */
 VALUE r_gmpf_set_prec(VALUE self, VALUE arg)
 {
   MP_FLOAT *self_val;
@@ -1435,6 +1771,8 @@ VALUE r_gmpf_set_prec(VALUE self, VALUE arg)
   } else {
     typeerror(X);
   }
+
+  return Qnil;  /* should never get here */
 }
 
 VALUE r_gmpf_set_prec_raw(VALUE self, VALUE arg)
@@ -1447,8 +1785,140 @@ VALUE r_gmpf_set_prec_raw(VALUE self, VALUE arg)
   } else {
     typeerror(X);
   }
+
+  return Qnil;  /* should never get here */
+}
+
+#ifdef MPFR
+
+#define DEFUN_FR_CLASS_M(fname,mpfr_fname)      \
+static VALUE r_gmpfrsg_get_##fname(VALUE klass) \
+{                                               \
+  (void)klass;                                  \
+  return INT2NUM (mpfr_fname ());               \
+}
+
+/*
+ * Document-method: GMP::F.emin
+ * call-seq:
+ *   GMP::F.emin
+ *
+ * Return the (current) smallest exponent allowed for a
+ * floating-point variable. The smallest positive value of a floating-point
+ * variable is one half times 2 raised to the smallest exponent.
+ *
+ * @since 0.7.19
+ */
+DEFUN_FR_CLASS_M(emin,mpfr_get_emin)
+
+/*
+ * Document-method: GMP::F.emax
+ * call-seq:
+ *   GMP::F.emax
+ *
+ * Return the (current) largest exponent allowed for a floating-point variable.
+ * The largest floating-point value has the form (1 - epsilon) times 2 raised
+ * to the largest exponent, where epsilon depends on the precision of the
+ * considered variable.
+ *
+ * @since 0.7.19
+ */
+DEFUN_FR_CLASS_M(emax,mpfr_get_emax)
+
+/*
+ * Document-method: GMP::F.emin_min
+ * call-seq:
+ *   GMP::F.emin_min
+ *
+ * Return the minimum exponent allowed for GMP::F.emin=()
+ *
+ * @since 0.7.19
+ */
+DEFUN_FR_CLASS_M(emin_min,mpfr_get_emin_min)
+
+/*
+ * Document-method: GMP::F.emin_max
+ * call-seq:
+ *   GMP::F.emin_max
+ *
+ * Return the maximum exponent allowed for GMP::F.emin=()
+ *
+ * @since 0.7.19
+ */
+DEFUN_FR_CLASS_M(emin_max,mpfr_get_emin_max)
+
+/*
+ * Document-method: GMP::F.emax_min
+ * call-seq:
+ *   GMP::F.emax_min
+ *
+ * Return the minimum exponent allowed for GMP::F.emax=()
+ *
+ * @since 0.7.19
+ */
+DEFUN_FR_CLASS_M(emax_min,mpfr_get_emax_min)
+
+/*
+ * Document-method: GMP::F.emax_max
+ * call-seq:
+ *   GMP::F.emax_max
+ *
+ * Return the maximum exponent allowed for GMP::F.emax=()
+ *
+ * @since 0.7.19
+ */
+DEFUN_FR_CLASS_M(emax_max,mpfr_get_emax_max)
+
+/*
+ * Document-method: GMP::F.emin=
+ * call-seq:
+ *   GMP::F.emin=(exp)
+ *
+ * Set the smallest exponent allowed for a floating-point variable.
+ *
+ * @since 0.7.19
+ */
+VALUE r_gmpfrsg_set_emin(VALUE klass, VALUE arg_val)
+{
+  (void)klass;
+
+  if (! FIXNUM_P (arg_val))
+    typeerror_as (X, "exp");
+
+  mpfr_set_emin (FIX2NUM (arg_val));
+  /* TODO: figure out a way to generate this RangeError:
+    if (success != 0)
+      rb_raise(rb_eRangeError, "exp must be in-range");*/
+
+  return Qnil;
 }
 
+/*
+ * Document-method: GMP::F.emax=
+ * call-seq:
+ *   GMP::F.emax=(exp)
+ *
+ * Set the largest exponent allowed for a floating-point variable.
+ *
+ * @since 0.7.19
+ */
+VALUE r_gmpfrsg_set_emax(VALUE klass, VALUE arg_val)
+{
+  (void)klass;
+
+  if (! FIXNUM_P (arg_val))
+    typeerror_as (X, "exp");
+
+  mpfr_set_emax (FIX2NUM (arg_val));
+  /* TODO: figure out a way to generate this RangeError:
+    if (success != 0)
+      rb_raise(rb_eRangeError, "exp must be in-range");*/
+
+  return Qnil;
+}
+
+#endif  /* MPFR */
+
 
 void init_gmpf()
 {
@@ -1462,6 +1932,7 @@ void init_gmpf()
   rb_define_singleton_method(cGMP_F, "new", r_gmpfsg_new, -1);
   rb_define_method(cGMP_F, "initialize", r_gmpf_initialize, -1);
 #ifdef MPFR
+  rb_define_singleton_method(cGMP_F, "new_2exp", r_gmpfsg_new_2exp, -1);
   rb_define_singleton_method(cGMP_F, "nan", r_gmpfsg_nan, 0);
   rb_define_singleton_method(cGMP_F, "inf", r_gmpfsg_inf, -1);
 #if MPFR_VERSION_MAJOR>2
@@ -1472,6 +1943,17 @@ void init_gmpf()
   rb_define_method(cGMP_F, "prec=", r_gmpf_set_prec, 1);
   rb_define_method(cGMP_F, "prec_raw=", r_gmpf_set_prec_raw, 1);
 
+#ifdef MPFR
+  rb_define_singleton_method(cGMP_F, "emin", r_gmpfrsg_get_emin, 0);
+  rb_define_singleton_method(cGMP_F, "emax", r_gmpfrsg_get_emax, 0);
+  rb_define_singleton_method(cGMP_F, "emin=", r_gmpfrsg_set_emin, 1);
+  rb_define_singleton_method(cGMP_F, "emax=", r_gmpfrsg_set_emax, 1);
+  rb_define_singleton_method(cGMP_F, "emin_min", r_gmpfrsg_get_emin_min, 0);
+  rb_define_singleton_method(cGMP_F, "emin_max", r_gmpfrsg_get_emin_max, 0);
+  rb_define_singleton_method(cGMP_F, "emax_min", r_gmpfrsg_get_emax_min, 0);
+  rb_define_singleton_method(cGMP_F, "emax_max", r_gmpfrsg_get_emax_max, 0);
+#endif  /* MPFR */
+
   // Converting Floats
   rb_define_method(cGMP_F, "to_s", r_gmpf_to_s, -1);
   rb_define_alias(cGMP_F, "inspect", "to_s");
@@ -1519,7 +2001,6 @@ void init_gmpf()
   /* TODO: new in MPFR 3.0.0:
    *
    * mpfr_ai
-   * mpfr_set_z_2exp
    */
 
   /* TODO: new in MPFR 3.1.0: