gmp 0.5.3-x86-mingw32 → 0.5.23-x86-mingw32

data/ext/gmp.c

@@ -98,55 +98,6 @@ static VALUE r_gmpfsg_set_default_prec(VALUE klass, VALUE arg)
 }
 
 #ifdef MPFR
-static VALUE r_gmpfsg_get_default_rounding_mode(VALUE klass)
-{
-  (void)klass;
-  const char *rounding_string_val;
-  rounding_string_val = mpfr_print_rnd_mode (mpfr_get_default_rounding_mode ());
-  if ( rounding_string_val == NULL ) {
-    return Qnil;
-  }
-  else {
-    return rb_const_get (mGMP, rb_intern (rounding_string_val));
-  }
-}
-
-static VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
-{
-  (void)klass;
-  VALUE mode;
-  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.");
-    }
-  } else {
-    rb_raise(rb_eTypeError, "rounding mode must be one of the rounding mode constants.");
-  }
-  
-  switch (FIX2INT(mode)) {
-    case 0:
-      mpfr_set_default_rounding_mode (GMP_RNDN);
-      break;
-    case 1:
-      mpfr_set_default_rounding_mode (GMP_RNDZ);
-      break;
-    case 2:
-      mpfr_set_default_rounding_mode (GMP_RNDU);
-      break;
-    case 3:
-      mpfr_set_default_rounding_mode (GMP_RNDD);
-      break;
-#if MPFR_VERSION_MAJOR>2
-    case 4:
-      mpfr_set_default_rounding_mode (MPFR_RNDA);
-      break;
-#endif
-  }
-  
-  return Qnil;
-}
-
 mp_rnd_t r_get_rounding_mode(VALUE rnd)
 {
   VALUE mode;
@@ -193,12 +144,13 @@ mp_rnd_t r_get_rounding_mode(VALUE rnd)
 
 void Init_gmp() {
   mGMP = rb_define_module("GMP");
-  rb_define_const(mGMP, "GMP_VERSION", rb_str_new2(gmp_version));
-  rb_define_const(mGMP, "GMP_CC", rb_str_new2(__GMP_CC));
-  rb_define_const(mGMP, "GMP_CFLAGS", rb_str_new2(__GMP_CFLAGS));
+  rb_define_const(mGMP, "GMP_VERSION",       rb_str_new2(gmp_version));
+  rb_define_const(mGMP, "GMP_CC",            rb_str_new2(__GMP_CC));
+  rb_define_const(mGMP, "GMP_CFLAGS",        rb_str_new2(__GMP_CFLAGS));
   rb_define_const(mGMP, "GMP_BITS_PER_LIMB", INT2FIX(mp_bits_per_limb));
+  rb_define_const(mGMP, "GMP_NUMB_MAX",      ULONG2NUM(GMP_NUMB_MAX));
 #ifdef MPFR
-  rb_define_const(mGMP, "MPFR_VERSION", rb_str_new2(MPFR_VERSION_STRING));
+  rb_define_const(mGMP, "MPFR_VERSION",  rb_str_new2(MPFR_VERSION_STRING));
   rb_define_const(mGMP, "MPFR_PREC_MIN", INT2FIX(MPFR_PREC_MIN));
   rb_define_const(mGMP, "MPFR_PREC_MAX", INT2FIX(MPFR_PREC_MAX));
 #endif /* MPFR */
@@ -220,8 +172,6 @@ void Init_gmp() {
   rb_define_singleton_method (cGMP_F, "default_prec=", r_gmpfsg_set_default_prec, 1);
 #ifdef MPFR
   cGMP_Rnd = rb_define_class_under (mGMP, "Rnd", rb_cObject);
-  rb_define_singleton_method (cGMP_F, "default_rounding_mode", r_gmpfsg_get_default_rounding_mode, 0);
-  rb_define_singleton_method (cGMP_F, "default_rounding_mode=", r_gmpfsg_set_default_rounding_mode, 1);
   init_gmprnd ();
 #endif /* MPFR */
   rb_define_method (cGMP_F, "coerce", r_gmpf_coerce, 1); // new method - testing

data/ext/gmpf.c

@@ -10,17 +10,6 @@
  * 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.
- *
- * The following list is just a simple checklist for me, really. A better
- * reference should be found in the rdocs.
- *
- *   Ruby method    C Extension function    GMP function
- *   to_d           r_gmpf_to_d             mpf_get_d
- *   to_s           r_gmpf_to_s             mpf_get_s
- *   +              r_gmpf_add              mpf_add
- *   -              r_gmpf_sub              mpf_sub
- *   *              r_gmpf_mul              mpf_mul
- *   /              r_gmpf_div              mpf_div
  */
 
 /**********************************************************************
@@ -250,6 +239,12 @@ VALUE r_gmpmod_f(int argc, VALUE *argv, VALUE module)
  *    Converting Floats                                               *
  **********************************************************************/
 
+/*
+ * call-seq:
+ *   x.to_d
+ *
+ * Returns _x_ as a Float.
+ */
 VALUE r_gmpf_to_d(VALUE self)
 {
   MP_FLOAT *self_val;
@@ -260,12 +255,10 @@ VALUE r_gmpf_to_d(VALUE self)
 
 #ifdef MPFR
 /*
- * Document-method: to_s
- *
  * call-seq:
- *   float.to_s
+ *   x.to_s
  *
- * Returns the decimal representation of +float+, as a string.
+ * Returns the decimal representation of _x_, as a String.
  */
 VALUE r_gmpf_to_s(VALUE self)
 {
@@ -301,12 +294,10 @@ VALUE r_gmpf_to_s(VALUE self)
 }
 #else
 /*
- * Document-method: to_s
- *
  * call-seq:
- *   float.to_s
+ *   x.to_s
  *
- * Returns the decimal representation of +float+, as a string.
+ * Returns the decimal representation of _x_, as a string.
  */
 VALUE r_gmpf_to_s(VALUE self)
 {
@@ -346,9 +337,9 @@ VALUE r_gmpf_to_s(VALUE self)
 #ifndef MPFR
 /*
  * call-seq:
- *   float + other
+ *   x + y
  *
- * Returns the sum of +float+ and +other+. +other+ can be
+ * Returns the sum of _x_ and _y_. _y_ must be an instance of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -404,9 +395,9 @@ VALUE r_gmpf_add(VALUE self, VALUE arg)
 #else
 /*
  * call-seq:
- *   float + other
+ *   x + y
  *
- * Returns the sum of +float+ and +other+. +other+ can be
+ * Returns the sum of _x_ and _y_. _y_ must be an instance of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -470,9 +461,9 @@ DEFUN_F_ZQXFBD2F(mul)
 
 /*
  * call-seq:
- *   float1 - float2
+ *   x - y
  *
- * Subtracts +float2+ from +float1+. +float2+ can be
+ * Subtracts _y_ from _x_. _y_ must be an instance of:
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -528,9 +519,9 @@ VALUE r_gmpf_sub(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   float * other
+ *   x * y
  *
- * Returns the product of +float+ and +other+. +other+ can be
+ * Returns the product of _x_ and _y_. _y_ can be
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -544,7 +535,6 @@ VALUE r_gmpf_mul(VALUE self, VALUE arg)
   MP_RAT *arg_val_q;
   MP_INT *arg_val_z;
   VALUE res;
-  //unsigned long prec;
   mpfr_prec_t prec;
 
   mpf_get_struct_prec (self, self_val, prec);
@@ -587,10 +577,10 @@ VALUE r_gmpf_mul(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   float ** integer
+ *   x ** y
  *
- * Returns +float+ raised to the +integer+ power. +integer+ must be
- * * Fixnum or Bignum
+ * 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)
@@ -617,65 +607,11 @@ VALUE r_gmpf_pow(VALUE self, VALUE arg)
   return res;
 }
 
-#ifdef MPFR
-/*
- * call-seq:
- *   float ** other
- *
- * Returns +float+ raised to the +other+ power. +other+ must be an instance of
- * * Fixnum
- * * Bignum
- * * Float
- * * GMP::Z
- * * GMP::F
- */
-/*VALUE r_gmpfr_pow(int argc, VALUE *argv, VALUE self)
-{
-  MP_FLOAT *self_val, *res_val, *arg_val_f;
-  VALUE arg, rnd_mode, res_prec;
-  unsigned long arg_val, prec, res_prec_value;
-  mp_rnd_t rnd_mode_value;
-  MP_INT *arg_val_z;
-  VALUE res;
-  
-  rb_scan_args (argc, argv, "12", &arg, &rnd_mode, &res_prec);
-
-  mpf_get_struct_prec (self, self_val, prec);
-  
-  if (NIL_P (rnd_mode)) { rnd_mode_value = __gmp_default_rounding_mode; }
-  else { rnd_mode_value = r_get_rounding_mode(rnd_mode); }
-  if (NIL_P (res_prec)) { res_prec_value = prec; }
-  else { res_prec_value = FIX2INT (res_prec); }
-  mpf_make_struct_init (res, res_val, res_prec_value);
-
-  if (FIXNUM_P(arg)) {
-    mpfr_pow_ui(res_val, self_val, FIX2NUM(arg), rnd_mode_value);
-  } else if (BIGNUM_P(arg)) {
-    mpz_temp_from_bignum(arg_val_z, arg);
-    mpfr_pow_z (res_val, self_val, arg_val_z, rnd_mode_value);
-    mpz_temp_free(arg_val_z);
-  } else if (FLOAT_P(arg)) {
-    r_mpf_set_d (res_val, NUM2DBL(arg));
-    mpfr_pow (res_val, self_val, res_val, rnd_mode_value);
-  } else if (GMPZ_P(arg)) {
-    mpz_get_struct (arg, arg_val_z);
-    mpfr_pow_z (res_val, self_val, arg_val_z, rnd_mode_value);
-  } else if (GMPF_P(arg)) {
-    mpf_get_struct (arg, arg_val_f);
-    mpfr_pow (res_val, self_val, arg_val_f, rnd_mode_value);
-  } else {
-    typeerror(ZFXBD);
-  }
-
-  return res;
-}*/
-#endif
-
 /*
  * call-seq:
- *   float1 / float2
+ *   x / y
  *
- * Divides +float1+ by +float2+. +float2+ can be
+ * Divides _x_ by _y_. _y_ can be
  * * GMP::Z
  * * Fixnum
  * * GMP::Q
@@ -729,45 +665,93 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
   return res;
 }
 
+#ifdef MPFR
+/*
+ * call-seq:
+ *   float ** other
+ *
+ * Returns _x_ raised to the _y_ power. _y_ must be an instance of
+ * * Fixnum
+ * * Bignum
+ * * Float
+ * * GMP::Z
+ * * GMP::F
+ */
+/*VALUE r_gmpfr_pow(int argc, VALUE *argv, VALUE self)
+{
+  MP_FLOAT *self_val, *res_val, *arg_val_f;
+  VALUE arg, rnd_mode, res_prec;
+  unsigned long arg_val, prec, res_prec_value;
+  mp_rnd_t rnd_mode_value;
+  MP_INT *arg_val_z;
+  VALUE res;
+  
+  rb_scan_args (argc, argv, "12", &arg, &rnd_mode, &res_prec);
+
+  mpf_get_struct_prec (self, self_val, prec);
+  
+  if (NIL_P (rnd_mode)) { rnd_mode_value = __gmp_default_rounding_mode; }
+  else { rnd_mode_value = r_get_rounding_mode(rnd_mode); }
+  if (NIL_P (res_prec)) { res_prec_value = prec; }
+  else { res_prec_value = FIX2INT (res_prec); }
+  mpf_make_struct_init (res, res_val, res_prec_value);
+
+  if (FIXNUM_P(arg)) {
+    mpfr_pow_ui(res_val, self_val, FIX2NUM(arg), rnd_mode_value);
+  } else if (BIGNUM_P(arg)) {
+    mpz_temp_from_bignum(arg_val_z, arg);
+    mpfr_pow_z (res_val, self_val, arg_val_z, rnd_mode_value);
+    mpz_temp_free(arg_val_z);
+  } else if (FLOAT_P(arg)) {
+    r_mpf_set_d (res_val, NUM2DBL(arg));
+    mpfr_pow (res_val, self_val, res_val, rnd_mode_value);
+  } else if (GMPZ_P(arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    mpfr_pow_z (res_val, self_val, arg_val_z, rnd_mode_value);
+  } else if (GMPF_P(arg)) {
+    mpf_get_struct (arg, arg_val_f);
+    mpfr_pow (res_val, self_val, arg_val_f, rnd_mode_value);
+  } else {
+    typeerror(ZFXBD);
+  }
 
+  return res;
+}*/
+#endif
 
 /*
  * Document-method: neg
  *
  * call-seq:
- *   float.neg
- *   -float
+ *   x.neg
+ *   -x
  *
- * From the GMP Manual:
- * 
- * Returns -+float+.
+ * Returns -_x_.
  */
 /*
  * Document-method: neg!
  *
  * call-seq:
- *   float.neg!
+ *   x.neg!
  *
- * Sets +float+ to -+float+.
+ * Sets _x_ to -_x_.
  */
 DEFUN_FLOAT2FLOAT(neg,mpf_neg)
 /*
  * Document-method: abs
  *
  * call-seq:
- *   float.abs
+ *   x.abs
  *
- * From the GMP Manual:
- * 
- * Returns the absolute value of +float+.
+ * Returns the absolute value of _x_.
  */
 /*
  * Document-method: abs!
  *
  * call-seq:
- *   float.abs!
+ *   x.abs!
  *
- * Sets +float+ to the absolute value of +float+.
+ * Sets _x_ to the absolute value of _x_.
  */
 DEFUN_FLOAT2FLOAT(abs,mpf_abs)
 
@@ -793,7 +777,10 @@ int mpf_cmp_value(MP_FLOAT *self_val, VALUE arg)
   }
 }
 
-/* what does really "equal" mean ? it's not obvious */
+/*
+ * 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...
+ */
 VALUE r_gmpf_eq(VALUE self, VALUE arg)
 {
   MP_FLOAT *self_val;
@@ -820,6 +807,28 @@ DEFUN_FLOAT_CMP(le,<=)
 DEFUN_FLOAT_CMP(gt,>)
 DEFUN_FLOAT_CMP(ge,>=)
 
+/*
+ * call-seq:
+ *   x.sgn
+ *
+ * Returns +1 if _x_ > 0, 0 if _x_ == 0, and -1 if _x_ < 0.
+ */
+VALUE r_gmpf_sgn(VALUE self)
+{
+  MP_FLOAT *self_val;
+  mpf_get_struct (self, self_val);
+  return INT2FIX (mpf_sgn (self_val));
+}
+
+
+/**********************************************************************
+ *    Miscellaneous Float Functions                                   *
+ **********************************************************************/
+
+DEFUN_FLOAT2FLOAT(floor,mpf_floor)
+DEFUN_FLOAT2FLOAT(trunc,mpf_trunc)
+DEFUN_FLOAT2FLOAT(ceil,mpf_ceil)
+
 
 #ifdef MPFR
 
@@ -827,15 +836,14 @@ DEFUN_FLOAT_CMP(ge,>=)
 VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)        \
 {                                                              \
   MP_FLOAT *self_val, *res_val;                                \
-  VALUE rnd_mode, res_prec;                                    \
+  VALUE rnd_mode, res_prec, res;                               \
   mpfr_prec_t prec, res_prec_value;                            \
   mp_rnd_t rnd_mode_val;                                       \
-  VALUE res;                                                   \
-                                                               \
-  rb_scan_args (argc, argv, "02", &rnd_mode, &res_prec);       \
                                                                \
   mpf_get_struct_prec (self, self_val, prec);                  \
-  if (NIL_P (rnd_mode)) { rnd_mode_val = __gmp_default_rounding_mode; }    \
+                                                               \
+  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; }             \
   else { res_prec_value = FIX2INT (res_prec); }                \
@@ -845,7 +853,31 @@ VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)        \
   return res;                                                  \
 }
 
-#define MPFR_SINGLE_1ARG_FUNCTION(name)                            \
+#define MPFR_DOUBLE_FUNCTION(name)                                   \
+VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)              \
+{                                                                    \
+  MP_FLOAT *self_val, *sin_val, *cos_val;                            \
+  VALUE rnd_mode, sin_prec, cos_prec, sinn, coss;                    \
+  mpfr_prec_t prec, sin_prec_val, cos_prec_val;                      \
+  mp_rnd_t rnd_mode_val;                                             \
+                                                                     \
+  mpf_get_struct_prec (self, self_val, prec);                        \
+                                                                     \
+  rb_scan_args (argc, argv, "03", &rnd_mode, &sin_prec, &cos_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 (sin_prec)) { sin_prec_val = prec; }                     \
+  else { sin_prec_val = FIX2INT (sin_prec); }                        \
+  if (NIL_P (cos_prec)) { cos_prec_val = sin_prec_val; }             \
+  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);                \
+  mpfr_##name (sin_val, cos_val, self_val, rnd_mode_val);            \
+                                                                     \
+  return rb_ary_new3(2, sinn, coss);                                 \
+}
+
+#define MPFR_SINGLE_LONG_FUNCTION(name)                            \
 VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)            \
 {                                                                  \
   MP_FLOAT *self_val, *res_val;                                    \
@@ -861,11 +893,35 @@ VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)            \
   if (NIL_P (res_prec)) { res_prec_value = prec; }                 \
   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, __gmp_default_rounding_mode);    \
+  mpfr_##name (res_val, arg1_val, self_val, __gmp_default_rounding_mode);  \
                                                                    \
   return res;                                                      \
 }
 
+#define MPFR_SINGLE_MPF_FUNCTION(name)                                     \
+VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)                    \
+{                                                                          \
+  MP_FLOAT *self_val, *arg1_val, *res_val;                                 \
+  VALUE arg1, rnd_mode, res_prec;                                          \
+  mpfr_prec_t prec, arg1_prec, res_prec_value;                             \
+  VALUE res;                                                               \
+  mp_rnd_t rnd_mode_val;                                                   \
+                                                                           \
+  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 (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; }                         \
+  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);                 \
+                                                                           \
+  return res;                                                              \
+}
+
 #define MPFR_SINGLE_BOOLEAN_FUNCTION(name)  \
 static VALUE r_gmpfr_##name(VALUE self)     \
 {                                           \
@@ -879,17 +935,26 @@ static VALUE r_gmpfr_##name(VALUE self)     \
 }
 
 
-#define MPFR_CONST_FUNCTION(name)                        \
-VALUE r_gmpfrsg_##name()                                 \
-{                                                        \
-  MP_FLOAT *res_val;                                     \
-  VALUE res;                                             \
-                                                         \
-  mpf_make_struct (res, res_val);                        \
-  mpf_init (res_val);                                    \
-  mpfr_##name (res_val, __gmp_default_rounding_mode);    \
-                                                         \
-  return res;                                            \
+#define MPFR_CONST_FUNCTION(name)                            \
+VALUE r_gmpfrsg_##name(int argc, VALUE *argv, VALUE self)    \
+{                                                            \
+  (void)self;                                                \
+  MP_FLOAT *res_val;                                         \
+  VALUE res;                                                 \
+  VALUE rnd_mode, prec;                                      \
+  mp_rnd_t rnd_mode_val;                                     \
+  mpfr_prec_t prec_val;                                      \
+                                                             \
+  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); }     \
+  if (NIL_P (prec)) { prec_val = mpfr_get_default_prec(); }  \
+  else { prec_val = FIX2INT (prec); }                        \
+  mpf_make_struct_init (res, res_val, prec_val);             \
+  mpfr_##name (res_val, rnd_mode_val);                       \
+                                                             \
+  return res;                                                \
 }
 
 MPFR_SINGLE_FUNCTION(sqrt)
@@ -905,18 +970,18 @@ MPFR_SINGLE_FUNCTION(exp10)
 MPFR_SINGLE_FUNCTION(cos)
 MPFR_SINGLE_FUNCTION(sin)
 MPFR_SINGLE_FUNCTION(tan)
+MPFR_DOUBLE_FUNCTION(sin_cos)
 MPFR_SINGLE_FUNCTION(sec)
 MPFR_SINGLE_FUNCTION(csc)
 MPFR_SINGLE_FUNCTION(cot)
-
 MPFR_SINGLE_FUNCTION(acos)
 MPFR_SINGLE_FUNCTION(asin)
 MPFR_SINGLE_FUNCTION(atan)
-
+MPFR_SINGLE_MPF_FUNCTION(atan2)
 MPFR_SINGLE_FUNCTION(cosh)
 MPFR_SINGLE_FUNCTION(sinh)
 MPFR_SINGLE_FUNCTION(tanh)
-
+MPFR_DOUBLE_FUNCTION(sinh_cosh)
 MPFR_SINGLE_FUNCTION(sech)
 MPFR_SINGLE_FUNCTION(csch)
 MPFR_SINGLE_FUNCTION(coth)
@@ -939,10 +1004,13 @@ MPFR_SINGLE_FUNCTION(erf)
 MPFR_SINGLE_FUNCTION(erfc)
 MPFR_SINGLE_FUNCTION(j0)
 MPFR_SINGLE_FUNCTION(j1)
-MPFR_SINGLE_1ARG_FUNCTION(jn)
+MPFR_SINGLE_LONG_FUNCTION(jn)
 MPFR_SINGLE_FUNCTION(y0)
 MPFR_SINGLE_FUNCTION(y1)
-MPFR_SINGLE_1ARG_FUNCTION(yn)
+MPFR_SINGLE_LONG_FUNCTION(yn)
+
+MPFR_SINGLE_MPF_FUNCTION(agm)
+MPFR_SINGLE_MPF_FUNCTION(hypot)
 
 MPFR_CONST_FUNCTION(const_log2)
 MPFR_CONST_FUNCTION(const_pi)
@@ -1010,32 +1078,84 @@ static VALUE r_gmpfr_pow(VALUE self, VALUE arg)
   return res;
 }
 
-#endif
-
-
 /**********************************************************************
- *    _unsorted_                                                      *
+ *    Rounding Related Functions                                      *
  **********************************************************************/
 
-DEFUN_FLOAT2FLOAT(floor,mpf_floor)
-DEFUN_FLOAT2FLOAT(trunc,mpf_trunc)
-DEFUN_FLOAT2FLOAT(ceil,mpf_ceil)
+VALUE r_gmpfsg_get_default_rounding_mode(VALUE klass)
+{
+  (void)klass;
+  const char *rounding_string_val;
+  rounding_string_val = mpfr_print_rnd_mode (mpfr_get_default_rounding_mode ());
+  if ( rounding_string_val == NULL ) {
+    return Qnil;
+  }
+  else {
+    return rb_const_get (mGMP, rb_intern (rounding_string_val));
+  }
+}
 
-/*
- * call-seq:
- *   float.sgn
- *
- * From the GMP Manual:
- * 
- * Returns +1 if +float+ > 0, 0 if +float+ == 0, and -1 if +float+ < 0.
- */
-VALUE r_gmpf_sgn(VALUE self)
+VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
+{
+  (void)klass;
+  VALUE mode;
+  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.");
+    }
+  } else {
+    rb_raise(rb_eTypeError, "rounding mode must be one of the rounding mode constants.");
+  }
+  
+  switch (FIX2INT(mode)) {
+    case 0:
+      mpfr_set_default_rounding_mode (GMP_RNDN); break;
+    case 1:
+      mpfr_set_default_rounding_mode (GMP_RNDZ); break;
+    case 2:
+      mpfr_set_default_rounding_mode (GMP_RNDU); break;
+    case 3:
+      mpfr_set_default_rounding_mode (GMP_RNDD); break;
+#if MPFR_VERSION_MAJOR>2
+    case 4:
+      mpfr_set_default_rounding_mode (MPFR_RNDA); break;
+#endif
+  }
+  
+  return Qnil;
+}
+ 
+VALUE r_gmpf_can_round(VALUE self, VALUE err, VALUE rnd1, VALUE rnd2, VALUE prec)
 {
   MP_FLOAT *self_val;
-  mpf_get_struct (self, self_val);
-  return INT2FIX (mpf_sgn (self_val));
+  mp_exp_t err_val;
+  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);
+  prec_val = FIX2INT (prec);
+  
+  if (mpfr_can_round (self_val, err_val, rnd1_val, rnd2_val, prec_val))
+    return Qtrue;
+  else
+    return Qfalse;
 }
 
+#endif
+
+
+/**********************************************************************
+ *    _unsorted_                                                      *
+ **********************************************************************/
+
 VALUE r_gmpf_get_prec(VALUE self)
 {
   MP_FLOAT *self_val;
@@ -1162,37 +1282,33 @@ void init_gmpf()
   //"unordered", r_gmpfr_unordered_p
   
   // Special Functions
-  rb_define_method(cGMP_F, "log",   r_gmpfr_log,   -1);
-  rb_define_method(cGMP_F, "log2",  r_gmpfr_log2,  -1);
-  rb_define_method(cGMP_F, "log10", r_gmpfr_log10, -1);
-  rb_define_method(cGMP_F, "exp",   r_gmpfr_exp,   -1);
-  rb_define_method(cGMP_F, "exp2",  r_gmpfr_exp2,  -1);
-  rb_define_method(cGMP_F, "exp10", r_gmpfr_exp10, -1);
-  rb_define_method(cGMP_F, "cos",   r_gmpfr_cos,   -1);
-  rb_define_method(cGMP_F, "sin",   r_gmpfr_sin,   -1);
-  rb_define_method(cGMP_F, "tan",   r_gmpfr_tan,   -1);
-  // "sin_cos", r_gmpfr_sin_cos
-  rb_define_method(cGMP_F, "sec",   r_gmpfr_sec,   -1);
-  rb_define_method(cGMP_F, "csc",   r_gmpfr_csc,   -1);
-  rb_define_method(cGMP_F, "cot",   r_gmpfr_cot,   -1);
-  
-  rb_define_method(cGMP_F, "acos",  r_gmpfr_acos,  -1);
-  rb_define_method(cGMP_F, "asin",  r_gmpfr_asin,  -1);
-  rb_define_method(cGMP_F, "atan",  r_gmpfr_atan,  -1);
-  // "atan2", r_gmpfr_atan2
-  
-  rb_define_method(cGMP_F, "cosh",  r_gmpfr_cosh,  -1);
-  rb_define_method(cGMP_F, "sinh",  r_gmpfr_sinh,  -1);
-  rb_define_method(cGMP_F, "tanh",  r_gmpfr_tanh,  -1);
-
-  // "sinh_cosh", r_gmpfr_sinh_cosh
-  
-  rb_define_method(cGMP_F, "sech",  r_gmpfr_sech,  -1);
-  rb_define_method(cGMP_F, "csch",  r_gmpfr_csch,  -1);
-  rb_define_method(cGMP_F, "coth",  r_gmpfr_coth,  -1);
-  rb_define_method(cGMP_F, "acosh", r_gmpfr_acosh, -1);
-  rb_define_method(cGMP_F, "asinh", r_gmpfr_asinh, -1);
-  rb_define_method(cGMP_F, "atanh", r_gmpfr_atanh, -1);
+  rb_define_method(cGMP_F, "log",       r_gmpfr_log,     -1);
+  rb_define_method(cGMP_F, "log2",      r_gmpfr_log2,    -1);
+  rb_define_method(cGMP_F, "log10",     r_gmpfr_log10,   -1);
+  rb_define_method(cGMP_F, "exp",       r_gmpfr_exp,     -1);
+  rb_define_method(cGMP_F, "exp2",      r_gmpfr_exp2,    -1);
+  rb_define_method(cGMP_F, "exp10",     r_gmpfr_exp10,   -1);
+  rb_define_method(cGMP_F, "cos",       r_gmpfr_cos,     -1);
+  rb_define_method(cGMP_F, "sin",       r_gmpfr_sin,     -1);
+  rb_define_method(cGMP_F, "tan",       r_gmpfr_tan,     -1);
+  rb_define_method(cGMP_F, "sin_cos",   r_gmpfr_sin_cos, -1);
+  rb_define_method(cGMP_F, "sec",       r_gmpfr_sec,     -1);
+  rb_define_method(cGMP_F, "csc",       r_gmpfr_csc,     -1);
+  rb_define_method(cGMP_F, "cot",       r_gmpfr_cot,     -1);
+  rb_define_method(cGMP_F, "acos",      r_gmpfr_acos,    -1);
+  rb_define_method(cGMP_F, "asin",      r_gmpfr_asin,    -1);
+  rb_define_method(cGMP_F, "atan",      r_gmpfr_atan,    -1);
+  rb_define_method(cGMP_F, "atan2",     r_gmpfr_atan2,   -1);
+  rb_define_method(cGMP_F, "cosh",      r_gmpfr_cosh,      -1);
+  rb_define_method(cGMP_F, "sinh",      r_gmpfr_sinh,      -1);
+  rb_define_method(cGMP_F, "tanh",      r_gmpfr_tanh,      -1);
+  rb_define_method(cGMP_F, "sinh_cosh", r_gmpfr_sinh_cosh, -1);
+  rb_define_method(cGMP_F, "sech",      r_gmpfr_sech,      -1);
+  rb_define_method(cGMP_F, "csch",      r_gmpfr_csch,      -1);
+  rb_define_method(cGMP_F, "coth",      r_gmpfr_coth,      -1);
+  rb_define_method(cGMP_F, "acosh",     r_gmpfr_acosh,     -1);
+  rb_define_method(cGMP_F, "asinh",     r_gmpfr_asinh,     -1);
+  rb_define_method(cGMP_F, "atanh",     r_gmpfr_atanh,     -1);
   
   // "fac", r_gmpfr_fac
 
@@ -1218,17 +1334,22 @@ void init_gmpf()
 
   // "fma", r_gmpfr_fma
   // "fms", r_gmpfr_fms
-  // "agm", r_gmpfr_agm
-  // "hypot", r_gmpfr_hypot
+  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
   
-  rb_define_singleton_method(cGMP_F, "const_log2",    r_gmpfrsg_const_log2,    0);
-  rb_define_singleton_method(cGMP_F, "const_pi",      r_gmpfrsg_const_pi,      0);
-  rb_define_singleton_method(cGMP_F, "const_euler",   r_gmpfrsg_const_euler,   0);
-  rb_define_singleton_method(cGMP_F, "const_catalan", r_gmpfrsg_const_catalan, 0);
+  rb_define_singleton_method(cGMP_F, "const_log2",    r_gmpfrsg_const_log2,    -1);
+  rb_define_singleton_method(cGMP_F, "const_pi",      r_gmpfrsg_const_pi,      -1);
+  rb_define_singleton_method(cGMP_F, "const_euler",   r_gmpfrsg_const_euler,   -1);
+  rb_define_singleton_method(cGMP_F, "const_catalan", r_gmpfrsg_const_catalan, -1);
 
   // Integer and Remainder Related Functions
   // "integer?", r_gmpfr_integer_p
+  
+  // Rounding Related Functions
+  rb_define_singleton_method (cGMP_F, "default_rounding_mode", r_gmpfsg_get_default_rounding_mode, 0);
+  rb_define_singleton_method (cGMP_F, "default_rounding_mode=", r_gmpfsg_set_default_rounding_mode, 1);
+  rb_define_method(cGMP_F, "can_round?",  r_gmpf_can_round, 4);
 #endif /* MPFR */
   
   // _unsorted_