gmp 0.6.43 → 0.6.47

data/CHANGELOG

@@ -1,3 +1,18 @@
+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.
+  * Added new optional rounding mode argument to GMP::F.new(Fixnum),
+    GMP::F.new(Bignum), GMP::F.new(GMP::Z), GMP::F.new(GMP::Q),
+    GMP::F.new(Float), and GMP::F.new(GMP::F) with tests (MPFR only)
+  * Added MPFR method GMP::RandState.mpfr_urandom (mpfr_urandom) and tests
+  * Added MPFR methods GMP::F#lessgreater? and GMP::F#unordered?, with sanity
+    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#frexp, documentation, and tests
+  * Fixed GMP::MPFR_RNDA
+
 0.6.43
   * Fixed compilation on OS X 10.9 Mavericks, using LLVM 5.0
   * Added license: Apache v2

data/README.markdown

@@ -1,6 +1,8 @@
 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):
 
@@ -158,12 +160,12 @@ as pi, are defined under class methods of GMP::F, listed below.
 * `GMP::GMP_VERSION` - A string like "5.0.1"
 * `GMP::GMP_CC` - The compiler used to compile GMP
 * `GMP::GMP_CFLAGS` - The CFLAGS used to compile GMP
-* `GMP::GMP\_BITS_PER_LIMB` The number of bits per limb
+* `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:
 * `GMP::MPFR_VERSION` - A string like "2.4.2"
-* `GMP::MPFR\_PREC_MIN` - The minimum precision available
+* `GMP::MPFR_PREC_MIN` - The minimum precision available
 * `GMP::MPFR_PREC_MAX` - The maximum precision available
 * `GMP::GMP_RNDN` - The constant representing "round to nearest"
 * `GMP::GMP_RNDZ` - The constant representing "round toward zero"
@@ -199,14 +201,13 @@ Numbers are created by using `new()`. Constructors can take following arguments:
     GMP::Q.new(any GMP::Z initializer)
     GMP::Q.new(any GMP::Z initializer, any GMP::Z initializer)
     GMP::F.new()
-    GMP::F.new(GMP::Z, precision=0)
-    GMP::F.new(GMP::Q, precision=0)
-    GMP::F.new(GMP::F)
-    GMP::F.new(GMP::F, precision)
+    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(Fixnum, precision=0)
-    GMP::F.new(Bignum, precision=0)
-    GMP::F.new(Float,  precision=0)
+    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::RandState.new(\[algorithm\] \[, algorithm_args\])
 
 You can also call them as:
@@ -236,7 +237,7 @@ Methods
       abs!                     in-place absolute value
       coerce                   promotion of arguments
       ==                       equality test
-      <=>,>=,>,<=,<            comparisions
+      <=>, >=, >, <=, <        comparisions
     class methods of GMP::Z
       fac(n)                   factorial of n
       2fac(n), double_fac(n)   double factorial of n
@@ -312,6 +313,7 @@ Methods
     class methods of GMP::F
       default_prec             get default precision
       default_prec=            set default precision
+      fac(n)                   new GMP::F, equal to factorial of n
     GMP::F
       prec                     get precision
       floor,ceil,trunc         nearest integer, GMP::F is returned, not GMP::Z
@@ -328,6 +330,9 @@ Methods
 
     *only if MPFR is available*
     class methods of GMP::F
+      nan                      returns NaN
+      inf(sign = 1)            returns Inf or -Inf
+      zero(sign = 1)           returns zero or -zero
       const_log2               returns the natural log of 2
       const_pi                 returns pi
       const_euler              returns euler
@@ -336,6 +341,9 @@ Methods
       mpfr_buildopt_decimal_p  returns whether MPFR was compiled with decimal
                                float support
     GMP::F
+      frexp                    frexp
+      lessgreater?(y)          x < y or y < x?
+      unordered?(y)            either x or y is NaN?
       sqrt                     square root of the object
       rec_sqrt                 square root of the recprical of the object
       cbrt                     cube root of the object
@@ -393,8 +401,10 @@ Methods
       number?                  |
       regular?                 / (MPFR_VERSION >= "3.0.0")
     GMP::RandState
-      mpfr_urandomb(fixnum)    get uniformly distributed random floating-point
-                               number within 0 <= rop < 1
+      mpfr_urandomb(prec = default)   get uniformly distributed random floating-point
+                                      number within 0 <= rop < 1
+      mpfr_urandom(prec = default)    get uniformly distributed random floating-point
+                                      number (MPFR_VERSION >= "3.0.0")
 
 Functional Mappings
 -------------------
@@ -584,7 +594,7 @@ Precision argument, and default_precision will be rounded up to whatever GMP thi
 Benchmarking
 ------------
 
-Please see [performance](https://github.com/srawlins/gmp/blob/master/performance.md) on GitHub.
+Please see [performance](https://github.com/srawlins/gmp/raw/master/performance.2012.pdf) on GitHub.
 
 License
 -------

data/ext/gmp.c

@@ -117,17 +117,24 @@ VALUE r_gmpsg_sprintf2(VALUE klass, VALUE format, VALUE arg) {
 mp_rnd_t r_get_rounding_mode(VALUE rnd)
 {
   VALUE mode;
-  
-  if (GMPRND_P(rnd)) {
+  int max_rnd;
+
+#if MPFR_VERSION_MAJOR>2
+  max_rnd = 4;
+#else
+  max_rnd = 3;
+#endif
+
+  if (GMPRND_P (rnd)) {
     mode = rb_funcall (rnd, 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) > 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.");
   }
-  
-  switch (FIX2INT(mode)) {
+
+  switch (FIX2INT (mode)) {
     case 0:
       return GMP_RNDN;
     case 1:

data/ext/gmpf.c

@@ -16,31 +16,31 @@
  *    Macros                                                          *
  **********************************************************************/
 
-#define DEFUN_FLOAT2FLOAT(fname,mpf_fname)                    \
-static VALUE r_gmpf_##fname(VALUE self)                       \
-{                                                             \
-  MP_FLOAT *self_val, *res_val;                               \
-  VALUE res;                                                  \
-  mpf_get_struct(self, self_val);                             \
-  mpf_make_struct_init(res, res_val, mpf_get_prec(self_val)); \
-  mpf_fname(res_val, self_val);                               \
-  return res;                                                 \
-}                                                             \
-                                                              \
-static VALUE r_gmpf_##fname##_self(VALUE self)                \
-{                                                             \
-  MP_FLOAT *self_val;                                         \
-  mpf_get_struct(self, self_val);                             \
-  mpf_fname(self_val, self_val);                              \
-  return Qnil;                                                \
+#define DEFUN_FLOAT2FLOAT(fname,mpf_fname)                  \
+static VALUE r_gmpf_##fname(VALUE self_val)                 \
+{                                                           \
+  MP_FLOAT *self, *res;                                     \
+  VALUE res_val;                                            \
+  mpf_get_struct (self_val, self);                          \
+  mpf_make_struct_init (res_val, res, mpf_get_prec(self));  \
+  mpf_fname (res, self);                                    \
+  return res_val;                                           \
+}                                                           \
+                                                            \
+static VALUE r_gmpf_##fname##_self(VALUE self)              \
+{                                                           \
+  MP_FLOAT *self_val;                                       \
+  mpf_get_struct (self, self_val);                          \
+  mpf_fname (self_val, self_val);                           \
+  return Qnil;                                              \
 }
 
-#define DEFUN_FLOAT_CMP(name,CMP_OP)                           \
-static VALUE r_gmpf_cmp_##name(VALUE self, VALUE arg)          \
-{                                                              \
-  MP_FLOAT *self_val;                                          \
-  mpf_get_struct(self,self_val);                               \
-  return (mpf_cmp_value(self_val, arg) CMP_OP 0)?Qtrue:Qfalse; \
+#define DEFUN_FLOAT_CMP(name,CMP_OP)                                 \
+static VALUE r_gmpf_cmp_##name(VALUE self_val, VALUE arg_val)        \
+{                                                                    \
+  MP_FLOAT *self;                                                    \
+  mpf_get_struct (self_val, self);                                   \
+  return (mpf_cmp_value (self, arg_val) CMP_OP 0) ? Qtrue : Qfalse;  \
 }
 
 
@@ -50,10 +50,33 @@ static VALUE r_gmpf_cmp_##name(VALUE self, VALUE arg)          \
 
 /*
  * call-seq:
- *   GMP::F.new(arg)
+ *   GMP::F.new(value)
+ *   GMP::F.new(value, precision)
+ *   GMP::F.new(value, precision, rounding_mode) (MPFR only)
+ *   GMP::F.new(string_value, precision, base)
+ *
+ * Creates a new GMP::F floating-point number, with _value_ as its value,
+ * converting where necessary.  _value_ must be an instance of one of the
+ * following classes:
  *
- * Creates a new GMP::F float, with arg as its value, converting where
- * necessary.
+ * * Fixnum
+ * * Bignum
+ * * GMP::Z
+ * * Float
+ * * GMP::Q
+ * * GMP::F
+ * * String
+ *
+ * @example
+ *   GMP::F.new(5)                    #=> 5
+ *   GMP::F(3**41)                    #=> 0.36472996377170788e+20
+ *   GMP::F(3**41, 32)                #=> 0.36472996375e+20
+ *   GMP::F(3**41, 32, GMP::GMP_RNDU) #=> 0.36472996384e+20
+ *   GMP::F.new("20")                 #=> 20
+ *   GMP::F.new("0x20")               #=> 32
+ *   GMP::F("111", 16)                #=> 111
+ *   GMP::F("111", 16, 2)             #=> 7
+ *   GMP::F("111", 16, 16)            #=> 273
  */
 VALUE r_gmpfsg_new(int argc, VALUE *argv, VALUE klass)
 {
@@ -62,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 # of arguments (%d for 0, 1 2, 3, or 4)", argc);
 
   mpf_make_struct (res, res_val);
   rb_obj_call_init(res, argc, argv);
@@ -75,6 +98,9 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
   MP_FLOAT *self_val, *arg_val_f;
   unsigned long prec = 0;
   VALUE arg;
+#ifdef MPFR
+  mp_rnd_t rnd_mode_val;
+#endif
   int base = 10;
 
   mpf_get_struct (self, self_val);
@@ -110,6 +136,8 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
     prec = mpf_get_prec (arg_val_f);
   }
 #ifdef MPFR
+  rnd_mode_val = __gmp_default_rounding_mode;
+
   if (prec == 0)
     mpfr_init (self_val);
   else
@@ -127,33 +155,45 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
         rb_raise(rb_eTypeError, "base must be a Fixnum");
       }
     }
+
     if (argc == 4) {
       // TODO: FIGURE IT OUT. ACCEPT A ROUNDING MODE!
     }
 
     mpf_set_value2 (self_val, arg, base);
     return Qnil;
+  } else {  /* not STRING_P(argv[0]) */
+    if (argc == 3)
+      rnd_mode_val = r_get_rounding_mode (argv[2]);
   }
 
-#else
+  if (GMPF_P (arg)) {
+    mpf_get_struct (arg, arg_val_f);
+    mpfr_set (self_val, arg_val_f, rnd_mode_val);
+  } else {
+    mpfr_set_value (self_val, arg, rnd_mode_val);
+  }
+
+#else  /* not MPFR */
   (void)base;
 
   if (prec == 0)
     r_mpf_init (self_val);
   else
     r_mpf_init2 (self_val, prec);
-#endif
 
   if (GMPF_P(arg)) {
     mpf_get_struct (arg, arg_val_f);
-    mpf_set(self_val, arg_val_f);
+    mpf_set (self_val, arg_val_f);
   } else {
-    mpf_set_value(self_val, arg);
+    mpf_set_value (self_val, arg);
   }
+#endif
 
   return Qnil;
 }
 
+#ifndef MPFR
 /* don't pass GMP::F here, it should be handled separately */
 void mpf_set_value(MP_FLOAT *self_val, VALUE arg)
 {
@@ -161,68 +201,149 @@ void mpf_set_value(MP_FLOAT *self_val, VALUE arg)
   MP_INT *arg_val_z;
   int result;
 
-#ifdef MPFR
-  if (GMPQ_P(arg)) {
-    mpq_get_struct(arg, arg_val_q);
-    r_mpf_set_q(self_val, arg_val_q);
-  } else if (GMPZ_P(arg)) {
-    mpz_get_struct(arg, arg_val_z);
-    r_mpf_set_z(self_val, arg_val_z);
-  } else if (FLOAT_P(arg)) {
-    mpfr_set_d(self_val, NUM2DBL(arg), __gmp_default_rounding_mode);
-  } else if (TYPE (arg) == T_FIXNUM) {
-    mpf_set_si(self_val, FIX2NUM(arg));
-  } else if (STRING_P(arg)) {
-    result = mpfr_set_str(self_val, StringValuePtr(arg), 10, __gmp_default_rounding_mode);
+  if (GMPQ_P (arg)) {
+    mpq_get_struct (arg, arg_val_q);
+    r_mpf_set_q (self_val, arg_val_q);
+  } else if (GMPZ_P (arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    r_mpf_set_z (self_val, arg_val_z);
+  } else if (FLOAT_P (arg)) {
+    r_mpf_set_d (self_val, NUM2DBL (arg));
+  } else if (FIXNUM_P (arg)) {
+    mpf_set_si (self_val, FIX2NUM (arg));
+  } else if (STRING_P (arg)) {
+    result = r_mpf_set_str (self_val, StringValuePtr (arg), 10);
     if (result == -1) {
-      rb_raise(rb_eRuntimeError, "Badly formatted string");
+      rb_raise (rb_eRuntimeError, "Badly formatted string");
     }
-  } else if (BIGNUM_P(arg)) {
+  } else if (BIGNUM_P (arg)) {
 #if 1 /* GMP3 code */
-    mpz_temp_from_bignum(arg_val_z, arg);
-    r_mpf_set_z(self_val, arg_val_z);
-    mpz_temp_free(arg_val_z);
-#endif
-#else
-  if (GMPQ_P(arg)) {
-    mpq_get_struct(arg, arg_val_q);
-    r_mpf_set_q(self_val, arg_val_q);
-  } else if (GMPZ_P(arg)) {
-    mpz_get_struct(arg, arg_val_z);
-    r_mpf_set_z(self_val, arg_val_z);
-  } else if (FLOAT_P(arg)) {
-    r_mpf_set_d(self_val, NUM2DBL(arg));
-  } else if (FIXNUM_P(arg)) {
-    mpf_set_si(self_val, FIX2NUM(arg));
+    mpz_temp_from_bignum (arg_val_z, arg);
+    r_mpf_set_z (self_val, arg_val_z);
+    mpz_temp_free (arg_val_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)));
+  }
+}
+
+#else /* MPFR */
+/* don't pass GMP::F here, it should be handled separately */
+void mpfr_set_value(MP_FLOAT *self_val, VALUE arg, mp_rnd_t rnd_mode_val)
+{
+  MP_RAT *arg_val_q;
+  MP_INT *arg_val_z;
+  int result;
+
+  if (GMPQ_P (arg)) {
+    mpq_get_struct (arg, arg_val_q);
+    r_mpfr_set_q (self_val, arg_val_q, rnd_mode_val);
+  } else if (GMPZ_P (arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    r_mpfr_set_z (self_val, arg_val_z, rnd_mode_val);
+  } else if (FLOAT_P (arg)) {
+    mpfr_set_d (self_val, NUM2DBL (arg), rnd_mode_val);
+  } else if (TYPE (arg) == T_FIXNUM) {
+    mpfr_set_si (self_val, FIX2NUM (arg), rnd_mode_val);
   } else if (STRING_P(arg)) {
-    result = r_mpf_set_str(self_val, StringValuePtr(arg), 10);
+    result = mpfr_set_str (self_val, StringValuePtr (arg), 10, rnd_mode_val);
     if (result == -1) {
       rb_raise(rb_eRuntimeError, "Badly formatted string");
     }
-  } else if (BIGNUM_P(arg)) {
+  } else if (BIGNUM_P (arg)) {
 #if 1 /* GMP3 code */
-    mpz_temp_from_bignum(arg_val_z, arg);
-    r_mpf_set_z(self_val, arg_val_z);
-    mpz_temp_free(arg_val_z);
-#endif
-#endif
+    mpz_temp_from_bignum (arg_val_z, arg);
+    r_mpfr_set_z (self_val, arg_val_z, rnd_mode_val);
+    mpz_temp_free (arg_val_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)));
+    rb_raise (rb_eTypeError, "Don't know how to convert %s into GMP::F", rb_class2name (rb_class_of (arg)));
   }
 }
 
-#ifdef MPFR
 void mpf_set_value2(MP_FLOAT *self_val, VALUE arg, int base)
 {
   int result;
 
-  result = mpfr_set_str(self_val, StringValuePtr(arg), base, __gmp_default_rounding_mode);
+  /* TODO use rnd_mode_val */
+  result = mpfr_set_str (self_val, StringValuePtr (arg), base, __gmp_default_rounding_mode);
 
   if (result == -1) {
-    rb_raise(rb_eRuntimeError, "Badly formatted string");
+    rb_raise (rb_eRuntimeError, "Badly formatted string");
   }
 }
-#endif
+
+/*
+ * call-seq:
+ *   GMP::F.nan
+ *
+ * NaN, an instance of GMP::F
+ */
+VALUE r_gmpfsg_nan(VALUE klass)
+{
+  MP_FLOAT *res;
+  VALUE res_val;
+  (void)klass;
+
+  mpf_make_struct_init (res_val, res, mpfr_get_default_prec());
+  mpfr_set_nan (res);
+
+  return res_val;
+}
+
+/*
+ * 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
+ */
+VALUE r_gmpfsg_inf(int argc, VALUE *argv, VALUE klass)
+{
+  MP_FLOAT *res;
+  VALUE sign_val, res_val;
+  int sign;
+  (void)klass;
+
+  rb_scan_args (argc, argv, "01", &sign_val);
+
+  if (NIL_P (sign_val))         { sign = 1; }
+  else if (FIXNUM_P (sign_val)) { sign = FIX2INT (sign_val); }
+  else                          { typeerror_as (X, "sign"); }
+  mpf_make_struct_init (res_val, res, mpfr_get_default_prec());
+  mpfr_set_inf (res, sign);
+
+  return res_val;
+}
+
+#if MPFR_VERSION_MAJOR > 2
+/*
+ * call-seq:
+ *   GMP::F.zero
+ *   GMP::F.zero(sign)
+ *
+ * zero or negative zero, an instance of GMP::F, depending on _sign_, a Fixnum
+ */
+VALUE r_gmpfsg_zero(int argc, VALUE *argv, VALUE klass)
+{
+  MP_FLOAT *res;
+  VALUE sign_val, res_val;
+  int sign;
+  (void)klass;
+
+  rb_scan_args (argc, argv, "01", &sign_val);
+
+  if (NIL_P (sign_val))         { sign = 1; }
+  else if (FIXNUM_P (sign_val)) { sign = FIX2INT (sign_val); }
+  else                          { typeerror_as (X, "sign"); }
+  mpf_make_struct_init (res_val, res, mpfr_get_default_prec());
+  mpfr_set_zero (res, sign);
+
+  return res_val;
+}
+#endif  /* MPFR_VERSION_MAJOR > 2 */
+#endif  /* MPFR */
 
 /*
  * call-seq:
@@ -255,86 +376,62 @@ VALUE r_gmpf_to_d(VALUE self)
   return rb_float_new(mpf_get_d(self_val));
 }
 
-#ifdef MPFR
 /*
  * call-seq:
- *   x.to_s
+ *   x.to_s(base = 10)
  *
- * Returns the decimal representation of _x_, as a String.
+ * Returns a representation of _x_, as a String. By default, the String will be
+ * the decimal representation. Any valid GMP base can be passed.
  */
-VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self)
+VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self_val)
 {
-  MP_FLOAT *self_val;
+  MP_FLOAT *self;
   char *str, *str2;
-  VALUE res;
+  VALUE res_val;
   mp_exp_t exponent;
   VALUE base_val;
   int base = 10;
 
-  mpf_get_struct(self, self_val);
+  mpf_get_struct (self_val, self);
 
   /* TODO: accept a second optional argument, n_digits */
-  rb_scan_args(argc, argv, "01", &base_val);
-  if (NIL_P(base_val)) { base = 10; }                /* default value */
-  else { base = get_base(base_val); }
-
-  str = mpfr_get_str(NULL, &exponent, base, 0, self_val, __gmp_default_rounding_mode);
-  if ((strcmp(str,  "NaN") == 0) ||
-      (strcmp(str,  "Inf") == 0) ||
-      (strcmp(str, "-Inf") == 0))
+  rb_scan_args (argc, argv, "01", &base_val);
+  if (NIL_P (base_val)) { base = 10; }                /* default value */
+  else { base = get_base (base_val); }
+
+#ifndef MPFR
+  str = mpf_get_str (NULL, &exponent, base, 0, self);
+#else
+  str = mpfr_get_str (NULL, &exponent, base, 0, self, __gmp_default_rounding_mode);
+#endif
+  if ((strcmp (str,  "NaN") == 0) ||
+      (strcmp (str,  "Inf") == 0) ||
+      (strcmp (str, "-Inf") == 0))
   {
-    res = rb_str_new2(str);
+    res_val = rb_str_new2 (str);
   }
   else
   {
     if (str[0] == '-')
-      __gmp_asprintf(&str2, "-0.%se%+ld", str+1, exponent);
+      __gmp_asprintf (&str2, "-0.%se%+ld", str+1, exponent);
     else
-      __gmp_asprintf(&str2, "0.%se%+ld", str, exponent);
+      __gmp_asprintf (&str2, "0.%se%+ld", str, exponent);
 
-    res = rb_str_new2(str2);
-    mpfr_free_str(str2);
+    res_val = rb_str_new2 (str2);
+#ifndef MPFR
+    free (str2);
+#else
+    mpfr_free_str (str2);
+#endif
   }
 
-  mpfr_free_str(str);
-  return res;
-}
+#ifndef MPFR
+  free (str);
 #else
-/*
- * call-seq:
- *   x.to_s
- *
- * Returns the decimal representation of _x_, as a string.
- */
-VALUE r_gmpf_to_s(VALUE self)
-{
-  MP_FLOAT *self_val;
-  char *str, *str2;
-  VALUE res;
-  mp_exp_t exponent;
-
-  mpf_get_struct(self, self_val);
-
-  str = mpf_get_str(NULL, &exponent, 10, 0, self_val);
-  if ((strcmp(str,  "NaN") == 0) ||
-      (strcmp(str,  "Inf") == 0) ||
-      (strcmp(str, "-Inf") == 0))
-  {
-    res = rb_str_new2(str);
-  }
-  else
-  {
-    if (str[0] == '-')
-      __gmp_asprintf(&str2, "-0.%se%+ld", str+1, exponent);
-    else
-      __gmp_asprintf(&str2, "0.%se%+ld", str, exponent);
-    res = rb_str_new2(str2);
-    free(str2);
-  }
-  free(str);
-  return res;
-}
+  mpfr_free_str (str);
 #endif
+  return res_val;
+}
 
 
 /**********************************************************************
@@ -777,7 +874,11 @@ int mpf_cmp_value(MP_FLOAT *self_val, VALUE arg)
     return r_mpf_cmp (self_val, arg_val);
   } else {
     mpf_temp_init(arg_val, mpf_get_prec (self_val));
+#ifndef MPFR
     mpf_set_value (arg_val, arg);
+#else
+    mpfr_set_value (arg_val, arg, __gmp_default_rounding_mode);
+#endif
     result = r_mpf_cmp (self_val, arg_val);
     mpf_temp_free(arg_val);
     return result;
@@ -786,7 +887,7 @@ 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, SRR, put in here? It is now obvious to me...
+ * Is this a note that I, srawlins, put in here? It is not obvious to me...
  */
 VALUE r_gmpf_eq(VALUE self, VALUE arg)
 {
@@ -827,6 +928,46 @@ VALUE r_gmpf_sgn(VALUE self)
   return INT2FIX (mpf_sgn (self_val));
 }
 
+#ifdef MPFR
+
+/*
+ * call-seq:
+ *   x.lessgreater?(y)
+ *
+ * Return true if _x_ < _y_ or _x_ > _y_; false otherwise
+ */
+VALUE r_gmpfr_lessgreater_p(VALUE self_val, VALUE arg_val)
+{
+  MP_FLOAT *self, *arg;
+
+  if (!GMPF_P (arg_val))
+    typeerror_as (F, "arg");
+
+  mpf_get_struct (self_val, self);
+  mpf_get_struct (arg_val, arg);
+  return (mpfr_lessgreater_p (self, arg) != 0) ? Qtrue : Qfalse;
+}
+
+/*
+ * call-seq:
+ *   x.unordered?(y)
+ *
+ * Return true if _x_ or _y_ is a NaN; false otherwise
+ */
+VALUE r_gmpfr_unordered_p(VALUE self_val, VALUE arg_val)
+{
+  MP_FLOAT *self, *arg;
+
+  if (!GMPF_P (arg_val))
+    typeerror_as (F, "arg");
+
+  mpf_get_struct (self_val, self);
+  mpf_get_struct (arg_val, arg);
+  return (mpfr_unordered_p (self, arg) != 0) ? Qtrue : Qfalse;
+}
+
+#endif  /* MPFR */
+
 
 /**********************************************************************
  *    Miscellaneous Float Functions                                   *
@@ -853,6 +994,7 @@ VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)        \
   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);               \
@@ -874,8 +1016,10 @@ VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)              \
   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 (sin_prec)) { sin_prec_val = prec; }                     \
+  /* TODO test type */                                               \
   else { sin_prec_val = FIX2INT (sin_prec); }                        \
   if (NIL_P (cos_prec)) { cos_prec_val = sin_prec_val; }             \
+  /* TODO test type */                                               \
   else { cos_prec_val = FIX2INT (cos_prec); }                        \
   mpf_make_struct_init (sinn, sin_val, sin_prec_val);                \
   mpf_make_struct_init (coss, cos_val, cos_prec_val);                \
@@ -922,6 +1066,7 @@ VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)                    \
   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);                 \
@@ -934,7 +1079,7 @@ static VALUE r_gmpfr_##name(VALUE self)     \
 {                                           \
   MP_FLOAT *self_val;                       \
                                             \
-  mpf_get_struct(self, self_val);           \
+  mpf_get_struct (self, self_val);          \
   if (mpfr_##name (self_val))               \
     return Qtrue;                           \
   else                                      \
@@ -955,15 +1100,48 @@ VALUE r_gmpfrsg_##name(int argc, VALUE *argv, VALUE self)    \
   rb_scan_args (argc, argv, "02", &rnd_mode, &prec);         \
                                                              \
   if (NIL_P (rnd_mode)) { rnd_mode_val = __gmp_default_rounding_mode; }  \
-  else { rnd_mode_val = r_get_rounding_mode(rnd_mode); }     \
+  else { rnd_mode_val = r_get_rounding_mode (rnd_mode); }    \
   if (NIL_P (prec)) { prec_val = mpfr_get_default_prec(); }  \
-  else { prec_val = FIX2INT (prec); }                        \
+  else if (FIXNUM_P (prec)) { prec_val = FIX2INT (prec); }   \
+  else { typeerror_as (Z, "prec"); }                         \
   mpf_make_struct_init (res, res_val, prec_val);             \
   mpfr_##name (res_val, rnd_mode_val);                       \
                                                              \
   return res;                                                \
 }
 
+/*
+ * 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.
+ */
+VALUE r_gmpfr_frexp(int argc, VALUE *argv, VALUE self_val)
+{
+  MP_FLOAT *self, *res;
+  VALUE rnd_mode_val, res_prec_val, exp_val, res_val;
+  mpfr_prec_t prec, res_prec;
+  mp_rnd_t rnd_mode;
+  mpfr_exp_t exp;
+
+  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 { res_prec = FIX2INT (res_prec_val); }
+  mpf_make_struct_init (res_val, res, res_prec);
+  mpfr_frexp (&exp, res, self, rnd_mode);
+  exp_val = INT2FIX (exp);
+
+  return rb_assoc_new(exp_val, res_val);
+}
+
 MPFR_SINGLE_FUNCTION(sqrt)
 MPFR_SINGLE_FUNCTION(rec_sqrt)
 MPFR_SINGLE_FUNCTION(cbrt)
@@ -1019,6 +1197,41 @@ MPFR_SINGLE_LONG_FUNCTION(yn)
 MPFR_SINGLE_MPF_FUNCTION(agm)
 MPFR_SINGLE_MPF_FUNCTION(hypot)
 
+/*
+ * call-seq:
+ *   GMP::F.fac(n)
+ *   GMP::F.fac(n, rounding_mode)
+ *   GMP::F.fac(n, rounding_mode, precision)
+ *
+ * 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.
+ */
+VALUE r_gmpfrsg_fac(int argc, VALUE *argv, VALUE self_val)
+{
+  MP_FLOAT *res;
+  VALUE arg_val, res_val;
+  VALUE rnd_mode_val, prec_val;
+  mp_rnd_t rnd_mode;
+  mpfr_prec_t prec;
+  unsigned long int arg;
+  (void)self_val;
+
+  rb_scan_args (argc, argv, "12", &arg_val, &rnd_mode_val, &prec_val);
+
+  if (FIXNUM_P (arg_val)) { arg = FIX2INT (arg_val); }
+  else { rb_raise (rb_eTypeError, "operand 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 (NIL_P (prec_val)) { prec = mpfr_get_default_prec(); }
+  /* TODO check type */
+  else { prec = FIX2INT (prec_val); }
+  mpf_make_struct_init (res_val, res, prec);
+  mpfr_fac_ui (res, arg, rnd_mode);
+
+  return res_val;
+}
+
 //VALUE r_gmpfrsg_sprintf(int argc, VALUE *argv, VALUE self)
   //rb_scan_args (argc, argv, "1*", &format, &list);
 VALUE r_gmpfrsg_sprintf2(VALUE klass, VALUE format, VALUE arg) {
@@ -1028,17 +1241,17 @@ VALUE r_gmpfrsg_sprintf2(VALUE klass, VALUE format, VALUE arg) {
   MP_INT *arg_val_z;
   MP_FLOAT *arg_val_f;
   (void)klass;
-  format_str = StringValuePtr(format);
-  if (GMPZ_P(arg)) {
+  format_str = StringValuePtr (format);
+  if (GMPZ_P (arg)) {
     mpz_get_struct (arg, arg_val_z);
-    mpfr_asprintf(&buffer, format_str, arg_val_z);
-  } else if (GMPF_P(arg)) {
+    mpfr_asprintf (&buffer, format_str, arg_val_z);
+  } else if (GMPF_P (arg)) {
     mpf_get_struct (arg, arg_val_f);
-    mpfr_asprintf(&buffer, format_str, arg_val_f);
+    mpfr_asprintf (&buffer, format_str, arg_val_f);
   }
 
-  res = rb_str_new2(buffer);
-  free(buffer);
+  res = rb_str_new2 (buffer);
+  free (buffer);
   return res;
 }
 
@@ -1248,6 +1461,13 @@ void init_gmpf()
   // Initializing, Assigning Floats
   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, "nan", r_gmpfsg_nan, 0);
+  rb_define_singleton_method(cGMP_F, "inf", r_gmpfsg_inf, -1);
+#if MPFR_VERSION_MAJOR>2
+  rb_define_singleton_method(cGMP_F, "zero", r_gmpfsg_zero, -1);
+#endif  /* MPFR_VERSION_MAJOR>2 */
+#endif  /* MPFR */
   rb_define_method(cGMP_F, "prec", r_gmpf_get_prec, 0);
   rb_define_method(cGMP_F, "prec=", r_gmpf_set_prec, 1);
   rb_define_method(cGMP_F, "prec_raw=", r_gmpf_set_prec_raw, 1);
@@ -1296,17 +1516,13 @@ void init_gmpf()
 
 
 #ifdef MPFR
-  /* To implement; new in MPFR 3.0.0:
+  /* TODO: new in MPFR 3.0.0:
    *
-   * mpfr_set_zero
    * mpfr_ai
-   * mpfr_set_flt
-   * mpfr_get_flt
-   * mpfr_urandom
    * mpfr_set_z_2exp
    */
 
-  /* To implement; new in MPFR 3.1.0:
+  /* TODO: new in MPFR 3.1.0:
    *
    * mpfr_buildopt_gmpinternals_p
    * mpfr_buildopt_tune_case
@@ -1314,19 +1530,18 @@ void init_gmpf()
    * mpfr_grandom
    * mpfr_z_sub
    */
+#if MPFR_VERSION_MAJOR >= 3 && MPFR_VERSION_MINOR >= 1
+  rb_define_method(cGMP_F, "frexp",    r_gmpfr_frexp,    -1);
+#endif  /* MPFR_VERSION >= 3.1 */
 
   // Basic Arithmetic Functions
   rb_define_method(cGMP_F, "sqrt",     r_gmpfr_sqrt,     -1);
   rb_define_method(cGMP_F, "rec_sqrt", r_gmpfr_rec_sqrt, -1);
   rb_define_method(cGMP_F, "cbrt",     r_gmpfr_cbrt,     -1);
-  // "root", r_gmpfr_root
-  // "neg", r_gmpfr_neg
-  // "abs", r_gmpfr_abs
-  // "dim", r_gmpfr_dim
-  // "mul_2", r_gmpfr_mul_2
-  // "div_2", r_gmpfr_div_2
-
-  //rb_define_method(cGMP_F, "**", r_gmpfr_pow, 1);
+  // TODO "root", r_gmpfr_root
+  // TODO "dim", r_gmpfr_dim
+  // TODO "mul_2", r_gmpfr_mul_2
+  // TODO "div_2", r_gmpfr_div_2
 
   // Comparison Functions
   rb_define_method(cGMP_F, "nan?", r_gmpfr_nan_p, 0);
@@ -1337,9 +1552,8 @@ void init_gmpf()
 #if MPFR_VERSION_MAJOR > 2
   rb_define_method(cGMP_F, "regular?", r_gmpfr_regular_p, 0);
 #endif
-  //"sgn", r_gmpfr_sgn
-  //"lessgreater", r_gmpfr_lessgreater_p
-  //"unordered", r_gmpfr_unordered_p
+  rb_define_method(cGMP_F, "lessgreater?", r_gmpfr_lessgreater_p, 1);
+  rb_define_method(cGMP_F, "unordered?",   r_gmpfr_unordered_p, 1);
 
   // Special Functions
   rb_define_method(cGMP_F, "log",       r_gmpfr_log,     -1);
@@ -1370,7 +1584,7 @@ void init_gmpf()
   rb_define_method(cGMP_F, "asinh",     r_gmpfr_asinh,     -1);
   rb_define_method(cGMP_F, "atanh",     r_gmpfr_atanh,     -1);
 
-  // "fac", r_gmpfr_fac
+  rb_define_singleton_method(cGMP_F, "fac", r_gmpfrsg_fac, -1);
 
   rb_define_method(cGMP_F, "log1p",   r_gmpfr_log1p,   -1);
   rb_define_method(cGMP_F, "expm1",   r_gmpfr_expm1,   -1);
@@ -1378,7 +1592,7 @@ void init_gmpf()
   rb_define_method(cGMP_F, "li2",     r_gmpfr_li2,     -1);
   rb_define_method(cGMP_F, "gamma",   r_gmpfr_gamma,   -1);
   rb_define_method(cGMP_F, "lngamma", r_gmpfr_lngamma, -1);
-  /*rb_define_method(cGMP_F, "lgamma",  r_gmpfr_lgamma,   -1);*/
+  /* TODO rb_define_method(cGMP_F, "lgamma",  r_gmpfr_lgamma,   -1); */
 #if MPFR_VERSION_MAJOR > 2
   rb_define_method(cGMP_F, "digamma", r_gmpfr_digamma, -1);
 #endif
@@ -1392,11 +1606,11 @@ void init_gmpf()
   rb_define_method(cGMP_F, "y1", r_gmpfr_y1,           -1);
   rb_define_method(cGMP_F, "yn", r_gmpfr_yn,           -1);
 
-  // "fma", r_gmpfr_fma
-  // "fms", r_gmpfr_fms
+  /* TODO "fma", r_gmpfr_fma */
+  /* TODO "fms", r_gmpfr_fms */
   rb_define_method(cGMP_F, "agm",   r_gmpfr_agm,       -1);
   rb_define_method(cGMP_F, "hypot", r_gmpfr_hypot,     -1);
-  // "ai", r_gmpfr_ai  !! 3.0.0
+  /* TODO "ai", r_gmpfr_ai  !! 3.0.0 */
 
   // Formatted Output Functions
   rb_define_singleton_method(cGMP_F, "sprintf2", r_gmpfrsg_sprintf2, 2);
@@ -1407,7 +1621,6 @@ void init_gmpf()
   rb_define_singleton_method(cGMP_F, "const_catalan", r_gmpfrsg_const_catalan, -1);
 
   // Integer and Remainder Related Functions
-  // "integer?", r_gmpfr_integer_p
   rb_define_method(cGMP_F, "integer?", r_gmpfr_integer_p, 0);
 
   // Rounding Related Functions
@@ -1421,6 +1634,4 @@ void init_gmpf()
   rb_define_singleton_method (cGMP_F, "mpfr_buildopt_tls_p", r_gmpfsg_mpfr_buildopt_tls_p, 0);
 #endif /* MPFR > 2 */
 #endif /* MPFR */
-
-  // _unsorted_
 }