gmp 0.6.43 → 0.6.47

data/ext/gmpq.c

@@ -82,11 +82,11 @@ VALUE r_gmpqsg_new(int argc, VALUE *argv, VALUE klass)
   (void)klass;
 
   if (argc > 2)
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0, 1 or 2)", argc);
+    rb_raise (rb_eArgError, "wrong # of arguments (%d for 0, 1 or 2)", argc);
 
   mpq_make_struct (res, res_val);
   mpq_init (res_val);
-  rb_obj_call_init(res, argc, argv);
+  rb_obj_call_init (res, argc, argv);
 
   return res;
 }
@@ -116,17 +116,17 @@ VALUE r_gmpq_initialize(int argc, VALUE *argv, VALUE self)
   MP_RAT *self_val, *arg_val;
 
   if (argc != 0) {
-    mpq_get_struct(self, self_val);
-    if (argc == 1 && GMPQ_P(argv[0])) {
-      mpq_get_struct(argv[0], arg_val);
+    mpq_get_struct (self, self_val);
+    if (argc == 1 && GMPQ_P (argv[0])) {
+      mpq_get_struct (argv[0], arg_val);
       mpq_set (self_val, arg_val);
-    } else if (argc == 1 && STRING_P(argv[0])) {
-      mpq_str_set (self_val, StringValuePtr(argv[0]));
+    } else if (argc == 1 && STRING_P (argv[0])) {
+      mpq_str_set (self_val, StringValuePtr (argv[0]));
     } else {
-      mpz_set_value (mpq_numref(self_val), argv[0], 0); // are these segfaulting?
+      mpz_set_value (mpq_numref (self_val), argv[0], 0); // are these segfaulting?
       if (argc == 2) {
-        mpz_set_value (mpq_denref(self_val), argv[1], 0); // are these segfaulting?
-        mpq_canonicalize(self_val);
+        mpz_set_value (mpq_denref (self_val), argv[1], 0); // are these segfaulting?
+        mpq_canonicalize (self_val);
       } // AND IF ARGC != 2 ?!? WHAT JUST HAPPENED?
     }
   }
@@ -142,7 +142,7 @@ VALUE r_gmpq_initialize(int argc, VALUE *argv, VALUE self)
 VALUE r_gmpmod_q(int argc, VALUE *argv, VALUE module)
 {
   (void)module;
-  return r_gmpqsg_new(argc, argv, cGMP_Q);
+  return r_gmpqsg_new (argc, argv, cGMP_Q);
 }
 
 /*
@@ -151,17 +151,17 @@ VALUE r_gmpmod_q(int argc, VALUE *argv, VALUE module)
  *
  * Efficiently swaps the contents of _p_ with _q_.
  */
-VALUE r_gmpq_swap(VALUE self, VALUE arg)
+VALUE r_gmpq_swap (VALUE self, VALUE arg)
 {
   MP_RAT *self_val, *arg_val;
 
-  if (!GMPQ_P(arg)) {
-    rb_raise(rb_eTypeError, "Can't swap GMP::Q with object of other class");
+  if (!GMPQ_P (arg)) {
+    rb_raise (rb_eTypeError, "Can't swap GMP::Q with object of other class");
   }
 
-  mpq_get_struct(self, self_val);
-  mpq_get_struct(arg, arg_val);
-  mpq_swap(self_val,arg_val);
+  mpq_get_struct (self, self_val);
+  mpq_get_struct (arg, arg_val);
+  mpq_swap (self_val,arg_val);
 
   return Qnil;
 }

data/ext/gmprandstate.c

@@ -284,37 +284,83 @@ VALUE r_gmprandstate_rrandomb(VALUE self, VALUE arg)
  *
  * Generate a uniformly distributed random float in the interval 0 <= rop < 1.
  */
-VALUE r_gmprandstate_mpfr_urandomb(int argc, VALUE *argv, VALUE self)
+VALUE r_gmprandstate_mpfr_urandomb(int argc, VALUE *argv, VALUE self_val)
 {
-  MP_RANDSTATE *self_val;
-  MP_FLOAT *res_val;
-  VALUE res;
+  MP_RANDSTATE *self;
+  MP_FLOAT *res;
+  VALUE res_val;
   unsigned long prec = 0;
-  
+
   if (argc > 1)
-    rb_raise (rb_eArgError, "wrong # of arguments(%d for 0 or 1)", argc);
+    rb_raise (rb_eArgError, "wrong # of arguments (%d for 0 or 1)", argc);
+
+  mprandstate_get_struct (self_val, self);
 
-  mprandstate_get_struct (self,self_val);
-  
   if (argc == 1) {
     if (FIXNUM_P (argv[0])) {
-      if (FIX2INT (argv[0]) >= 0)
-        prec = FIX2INT (argv[0]);
-      else
-        rb_raise (rb_eRangeError, "prec must be non-negative");
+      if (FIX2INT (argv[0]) < 2)
+        rb_raise (rb_eRangeError, "prec must be at least 2");
+
+      prec = FIX2INT (argv[0]);
     } else {
       rb_raise (rb_eTypeError, "prec must be a Fixnum");
     }
   }
-  
-  mpf_make_struct (res, res_val);
-  if (prec == 0) { mpf_init (res_val); }
-  else           { mpf_init2 (res_val, prec); }
-  
-  mpfr_urandomb (res_val, self_val);
-  
-  return res;
+
+  mpf_make_struct (res_val, res);
+  if (prec == 0) { mpf_init (res); }
+  else           { mpf_init2 (res, prec); }
+
+  mpfr_urandomb (res, self);
+
+  return res_val;
+}
+
+#if MPFR_VERSION_MAJOR > 2
+/*
+ * call-seq:
+ *   rand_state.mpfr_urandom()
+ *
+ * From the MPFR Manual:
+ *
+ * Generate a uniformly distributed random float. The floating-point number rop
+ * can be seen as if a random real number is generated according to the
+ * continuous uniform distribution on the interval [0, 1] and then rounded in
+ * the direction RNDN.
+ */
+VALUE r_gmprandstate_mpfr_urandom(int argc, VALUE *argv, VALUE self_val)
+{
+  MP_RANDSTATE *self;
+  MP_FLOAT *res;
+  mp_rnd_t rnd_mode;
+  VALUE res_val, prec_val, rnd_mode_val;
+  unsigned long int prec;
+
+  mprandstate_get_struct (self_val, self);
+
+  rb_scan_args (argc, argv, "02", &rnd_mode_val, &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 (prec_val)) {
+    prec = mpfr_get_default_prec();
+  } else if (FIXNUM_P (prec_val)) {
+    if (FIX2INT (prec_val) < 2)
+      rb_raise (rb_eRangeError, "prec must be at least 2");
+
+    prec = FIX2INT (prec_val);
+  } else {
+    rb_raise (rb_eTypeError, "prec must be a Fixnum");
+  }
+
+  mpf_make_struct (res_val, res);
+  mpf_init2 (res, prec);
+
+  mpfr_urandom (res, self, rnd_mode);
+
+  return res_val;
 }
+#endif /* MPFR_VERSION_MAJOR > 2 */
 #endif /* MPFR */
 
 
@@ -328,17 +374,20 @@ void init_gmprandstate()
   // Random State Initialization
   rb_define_singleton_method(cGMP_RandState, "new", r_gmprandstatesg_new, -1);
   rb_define_method(cGMP_RandState, "initialize", r_gmprandstate_initialize, -1);
-  
+
   // Random State Seeding
   rb_define_method(cGMP_RandState, "seed", r_gmprandstate_seed, 1);
-  
+
   // Integer Random Numbers
   rb_define_method(cGMP_RandState, "urandomb", r_gmprandstate_urandomb, 1);
   rb_define_method(cGMP_RandState, "urandomm", r_gmprandstate_urandomm, 1);
   rb_define_method(cGMP_RandState, "rrandomb", r_gmprandstate_rrandomb, 1);
-  
+
 #ifdef MPFR
   // Float Random Numbers
   rb_define_method(cGMP_RandState, "mpfr_urandomb", r_gmprandstate_mpfr_urandomb, -1);
+#if MPFR_VERSION_MAJOR > 2
+  rb_define_method(cGMP_RandState, "mpfr_urandom", r_gmprandstate_mpfr_urandom, -1);
+#endif /* MPFR_VERSION_MAJOR > 2 */
 #endif /* MPFR */
 }

data/ext/ruby_gmp.h

@@ -65,9 +65,12 @@ typedef __gmp_randstate_struct MP_RANDSTATE;
 #define GMPZ_P(value)   (rb_obj_is_instance_of(value, cGMP_Z) == Qtrue)
 #define GMPQ_P(value)   (rb_obj_is_instance_of(value, cGMP_Q) == Qtrue)
 #define GMPF_P(value)   (rb_obj_is_instance_of(value, cGMP_F) == Qtrue)
-#define mpz_set_bignum(var_mpz,var_bignum) {                   \
-  VALUE tmp = rb_funcall (rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32)), rb_intern("upcase"), 0);  \
-  mpz_set_str (var_mpz, StringValuePtr (tmp), 32);              \
+#define mpz_set_bignum(var_mpz,var_bignum) {                         \
+  VALUE tmp = rb_funcall (                                           \
+      rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX (32)),  \
+      rb_intern ("upcase"),                                          \
+      0);                                                            \
+  mpz_set_str (var_mpz, StringValuePtr (tmp), 32);                   \
 }
   /*VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32));  \*/
 /*#define mpz_set_bignum(var_mpz,var_bignum) {                   \
@@ -76,10 +79,10 @@ typedef __gmp_randstate_struct MP_RANDSTATE;
 }*/
 #define mpz_temp_alloc(var) { var=malloc(sizeof(MP_INT)); }
 #define mpz_temp_init(var) { mpz_temp_alloc(var); mpz_init(var); }
-#define mpz_temp_from_bignum(var,var_bignum) {                 \
-  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32));  \
-  mpz_temp_alloc(var);                                         \
-  mpz_init_set_str (var, StringValuePtr (tmp), 32);             \
+#define mpz_temp_from_bignum(var,var_bignum) {                               \
+  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX (32));  \
+  mpz_temp_alloc(var);                                                       \
+  mpz_init_set_str (var, StringValuePtr (tmp), 32);                          \
 }
 #define mpz_temp_free(var) { mpz_clear(var); free(var); }
 #define mpf_temp_alloc(var) { var=malloc(sizeof(MP_FLOAT)); }
@@ -90,20 +93,32 @@ typedef __gmp_randstate_struct MP_RANDSTATE;
 #endif
 
 #if defined(MPFR) && defined(HAVE_MPFR_H)
-#define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpfr_get_prec(c_var); }
-#define mpf_make_struct_init(ruby_var,c_var,prec) { mpf_make_struct(ruby_var,c_var); mpfr_init2 (c_var,prec); }
+#define mpf_get_struct_prec(ruby_var,c_var,prec) {  \
+  mpf_get_struct (ruby_var,c_var);                  \
+  prec = mpfr_get_prec (c_var);                     \
+}
+#define mpf_make_struct_init(ruby_var,c_var,prec) {  \
+  mpf_make_struct (ruby_var,c_var);                  \
+  mpfr_init2 (c_var,prec);                           \
+}
 #define mpf_temp_init(var,prec) { mpf_temp_alloc(var); mpfr_init2(var,prec); }
 #define mpf_temp_free(var) { mpfr_clear(var); free(var); }
 #define r_mpf_init(var1) (mpfr_init(var1))
 #define r_mpf_init2(var1, var2) (mpfr_init2(var1, var2))
-#define r_mpf_set_z(var1, var2) (mpfr_set_z(var1, var2, __gmp_default_rounding_mode))
-#define r_mpf_set_q(var1, var2) (mpfr_set_q(var1, var2, __gmp_default_rounding_mode))
+#define r_mpfr_set_z(var1, var2, rnd_mode) (mpfr_set_z(var1, var2, rnd_mode))
+#define r_mpfr_set_q(var1, var2, rnd_mode) (mpfr_set_q(var1, var2, rnd_mode))
 #define r_mpf_set_d(var1, var2) (mpfr_set_d(var1, var2, __gmp_default_rounding_mode))
 #define r_mpf_set_str(var1, var2, var3) (mpfr_set_str(var1, var2, var3, __gmp_default_rounding_mode))
 #define r_mpf_cmp(var1, var2) (mpfr_cmp(var1, var2))
-#else
-#define mpf_get_struct_prec(ruby_var,c_var,prec) { mpf_get_struct(ruby_var,c_var); prec = mpf_get_prec(c_var); }
-#define mpf_make_struct_init(ruby_var,c_var,prec) { mpf_make_struct(ruby_var,c_var); mpf_init2 (c_var,prec); }
+#else /* not MPFR */
+#define mpf_get_struct_prec(ruby_var,c_var,prec) {  \
+  mpf_get_struct (ruby_var,c_var);                  \
+  prec = mpf_get_prec (c_var);                      \
+}
+#define mpf_make_struct_init(ruby_var,c_var,prec) {  \
+  mpf_make_struct (ruby_var,c_var);                  \
+  mpf_init2 (c_var,prec);                            \
+}
 #define mpf_temp_init(var,prec) { mpf_temp_alloc(var); mpf_init2(var,prec); }
 #define mpf_temp_free(var) { mpf_clear(var); free(var); }
 #define r_mpf_init(var1) (mpf_init(var1))
@@ -113,7 +128,7 @@ typedef __gmp_randstate_struct MP_RANDSTATE;
 #define r_mpf_set_d(var1, var2) (mpf_set_d(var1, var2))
 #define r_mpf_set_str(var1, var2, var3) (mpf_set_str(var1, var2, var3))
 #define r_mpf_cmp(var1, var2) (mpf_cmp(var1, var2))
-#endif
+#endif /* MPFR */
 
 #ifdef FIXNUM_WIDTH       /* RBX check */
 #if (((8*SIZEOF_INTPTR_T) - TAG_FIXNUM_SHIFT -1) > 60) /* 64-bit */
@@ -136,6 +151,7 @@ typedef __gmp_randstate_struct MP_RANDSTATE;
 #define EXPECTED_ZX "Expected GMP::Z or Fixnum"
 #define EXPECTED_X "Expected Fixnum"
 #define EXPECTED_Z "Expected GMP::Z"
+#define EXPECTED_F "Expected GMP::F"
 #define EXPECTED_FD "Expected GMP::F or Float"
 #define typeerror(expected) rb_raise(rb_eTypeError, EXPECTED_##expected)
 #define typeerror_as(expected, argname) rb_raise(rb_eTypeError, EXPECTED_##expected " as " argname)
@@ -259,7 +275,11 @@ extern VALUE r_gmpq_den(VALUE self);
 // Initializing, Assigning Floats
 extern VALUE r_gmpfsg_new(int argc, VALUE *argv, VALUE klass);
 extern VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self);
+#ifndef MPFR
 extern void mpf_set_value(MP_FLOAT *self_val, VALUE arg);
+#else
+extern void mpfr_set_value(MP_FLOAT *self_val, VALUE arg, mpfr_rnd_t rnd_mode_val);
+#endif
 extern VALUE r_gmpmod_f(int argc, VALUE *argv, VALUE module);
 extern VALUE r_gmpf_get_prec(VALUE self);
 extern VALUE r_gmpf_set_prec(VALUE self, VALUE arg);
@@ -267,11 +287,7 @@ extern VALUE r_gmpf_set_prec_raw(VALUE self, VALUE arg);
 
 // Converting Floats
 extern VALUE r_gmpf_to_d(VALUE self);
-#ifdef MPFR
 extern VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self);
-#else
-extern VALUE r_gmpf_to_s(VALUE self);
-#endif
 
 // Float Arithmetic
 #ifndef MPFR

data/manual.tex

@@ -34,8 +34,8 @@
 \huge{gmp} &\\
 \midrule[3pt]
 \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
-\multicolumn{2}{r}{\large{Edition 0.6.41}}\\
-\multicolumn{2}{r}{\large{15 October 2013}}
+\multicolumn{2}{r}{\large{Edition 0.6.47}}\\
+\multicolumn{2}{r}{\large{31 December 2013}}
 \end{tabular}
 
 \vfill
@@ -48,7 +48,7 @@ This manual describes how to use the gmp Ruby gem, which provides bindings to
 the GNU multiple precision arithmetic library, version 4.3.x or 5.x.\\
 \\
 Copyright 2009, 2010, 2011, 2012, 2013 Sam Rawlins.\\
-No license yet.
+Apache License, Version 2.0
 \newpage
 
 \tableofcontents
@@ -1206,9 +1206,106 @@ There is also a convenience method available, \texttt{GMP::Q()}.\\
 
 \subsection{Initializing, Assigning Floats}
 
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{new} & & GMP::F.new $\rightarrow$ \textit{float} \\
+& & GMP::F.new(\textit{numeric}, \begin{small}precision = default, rnd\_mode = GMP\_RNDN\end{small}) $\rightarrow$ \textit{float} \\
+& & GMP::F.new(\textit{str}, \begin{small}base = 0\end{small}) $\rightarrow$ \textit{float} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  This method creates a new \gmpfs float. It typically takes one optional
+  argument for the value of the float. This argument can be one of several
+  classes. Optionally, a precision can be passed.\newline
+
+  If MPFR is available, an optional rounding mode can also be passed.
+  \newline
+
+  If the first argument is a String, then a second argument, the base, may be
+  optionally supplied.  Here are some examples:\newline
+
+  \texttt{GMP::F.new \qqqquad\qqqquad \#=> 0 (default) \newline
+          GMP::F.new(5) \qqqquad\qquad\  \#=> 5 (Ruby Fixnum) \newline
+          GMP::F.new(GMP::Z.new(31))  \#=> 31 (GMP Integer)\newline
+          GMP::F.new(3**41) \qqqquad\  \#=> 0.36472996377170788e+20\newline
+          >\qqqquad\qqqquad\qqqquad\qquad\quad (Ruby Bignum)\newline
+          GMP::F.new(3**41, 32) \qquad\  \#=> 0.36472996375+20\newline
+          >\qqqquad\qqqquad\qqqquad\qquad\quad (Ruby Bignum with precision)\newline
+          GMP::F.new(3**41, 32, GMP::GMP\_RNDU) \#=> 0.36472996375+20\newline
+          >\qqqquad\qqqquad\  (Ruby Bignum with precision and a rounding mode)\newline
+          GMP::F.new("20") \qqqquad\quad \#=> 20 (Ruby String)\newline
+          GMP::F.new("0x20") \qqqquad \#=> 32 (Ruby hexadecimal-format String)\newline
+          GMP::F.new("111", 16) \qquad\  \#=> 111 (Ruby String with precision)\newline
+          GMP::F.new("111", 16, 2) \quad \#=> 7\newline
+          >\qqqquad\qqqquad\qqqquad\quad (Ruby String with precision and a base)}
+}
+\end{tabular}
+\newline\newline
+
+There is also a convenience method available, \texttt{GMP::F()}.\\
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{nan} & (MPFR only) & GMP::F.nan $\rightarrow$ \textit{NaN} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns NaN, an instance of \gmpfs.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{inf} & (MPFR only) & GMP::F.inf(\textit{sign} = 1) $\rightarrow$ \textit{Inf} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns Inf (positive infinity) or -Inf (negative infinity), an instance of
+  \gmpfs, based on the sign of \textit{sign}, which must be a Fixnum, and
+  defaults to 1.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{zero} & (MPFR only) & GMP::F.zero(\textit{sign} = 1) $\rightarrow$ \textit{zero} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns zero or -zero, an instance of \gmpfs, based on the sign of
+  \textit{sign}, which must be a Fixnum, and defaults to 1.
+}
+\end{tabular}
+\newline\newline
+
+\subsection{Floating-point Conversion Functions}
+
+Every method below accepts two additional parameters in addition to any
+required parameters. These are $rnd\_mode$, the rounding mode to use in
+calculation, which defaults to \textit{GMP::GMP\_RNDN}, and $res\_prec$, the
+precision of the result, which defaults to the \textit{f.prec}, the precision
+of $f$.\\
+
+TONS OF MISSING DOCUMENTATION\\
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{frexp}   & (MPFR 3.1 only) & $f$.frexp(\begin{small}rnd\_mode = GMP\_RNDN, res\_prec=$f$.prec\end{small}) $\rightarrow$ $exp$, $g$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Set $exp$ and $y$ such that $0.5 <= abs(y) < 1$ and $y$ times 2 raised to
+  $exp$ equals $x$ rounded to $res\_prec$, using $rnd\_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.
+}
+\end{tabular}
+\newline\newline
+
 \subsection{Floating-point Special Functions (MPFR Only)}
 
-Every method below accepts two additional parameters in addition to any required parameters. These are $rnd\_mode$, the rounding mode to use in calculation, which defaults to \textit{GMP::GMP\_RNDN}, and $res\_prec$, the precision of the result, which defaults to the \textit{f.prec}, the precision of $f$.\\
+Every method below accepts two additional parameters in addition to any
+required parameters. These are $rnd\_mode$, the rounding mode to use in
+calculation, which defaults to \textit{GMP::GMP\_RNDN}, and $res\_prec$, the
+precision of the result, which defaults to the \textit{f.prec}, the precision
+of $f$.\\
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
@@ -1507,7 +1604,45 @@ Every method below accepts two additional parameters in addition to any required
 }
 \end{tabular}
 
-\subsection{Floating-point Miscellaneous Functions (MPFR Only)}
+\subsection{Floating-Point Random Numbers (MPFR only)}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{mpfr\_urandomb} & & $state$.mpfr\_urandomb() $\rightarrow$ $floating-point$ \\
+& & $state$.mprf\_urandomb($prec$) $\rightarrow$ $floating-point$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Generates a uniformly distributed random float in the between $0$ and $1$.
+  More precisely, the number can be seen as a float with a random non-normalized
+  significand and exponent 0, which is then normalized (thus if $e$ denotes the
+  exponent after normalization, then the least $-e$ significant bits of the
+  significand are always 0).
+
+  Optionally pass $prec$, the precision of the resultant GMP::F number.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{mpfr\_urandom} & & $state$.mpfr\_urandom() $\rightarrow$ $integer$ \\
+& & $state$.mprf\_urandom($rnd\_mode$) $\rightarrow$ $floating-point$ \\
+& & $state$.mprf\_urandom($rnd\_mode$, $prec$) $\rightarrow$ $floating-point$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Generate a uniformly distributed random float. The floating-point number
+  can be seen as if a random real number is generated according to the continuous
+  uniform distribution on the interval [0, 1] and then rounded in the direction
+  $rnd$.
+
+  Optionally pass $rnd\_mode$, a rounding mode.
+
+  Also optionally pass $prec$, the precision of the resultant GMP::F number.
+}
+\end{tabular}
+\newline\newline
+
+\subsection{Floating-point Miscellaneous Functions (MPFR only)}
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule