gmp 0.4.7-x86-mingw32 → 0.5.3-x86-mingw32

data/CHANGELOG

@@ -1,3 +1,34 @@
+0.5.3:
+  * Now supporting GMP 5.0.1 (I now test with GMP 4.3.2 and 5.0.1).
+  * Now supporting MPFR 3.0.0 (I now test with MPFR 2.4.2 and 3.0.0).
+  * Now supporting Ruby 1.9.2. A few changes had to be made.
+  * Added MPFR method GMP::F.zero? (mpfr_zero_p) with tests.
+  * Added MPFR method GMP::F.regular? (mpfr_regular_p) with tests (MPFR 3.0.0
+    only).
+  * Added MPFR methods GMP::F.rec_sqrt (mpfr_rec_sqrt) and GMP::F.cbrt
+    (mpfr_rec_cbrt), both heavily tested.
+  * Added MPFR method GMP::F.digamma (mpfr_digamma), not tested.
+  * Added GMP::F.prec= (mpf_set_prec) and GMP::F.prec_raw= (mpf_set_prec_raw),
+    neither tested yet.
+  * Added a dramatic amount of content to the manual. 26 pages.
+  * Unit test results: 98 tests, 11974 assertions, 0 failures, 0 errors
+  * Unit test results: 98 tests, 11961 assertions, 0 failures, 0 errors (MPFR 2.4.2)
+  * Unit test results: 79 tests, 742 assertions, 0 failures, 0 errors (w/o MPFR)
+
+0.4.19:
+  * Added FIX2NUM macro to help support x86_64.
+  * Fixed bug in MPRF functions; they were not using specified rounding modes.
+  * Added ** (pow) to GMP::F (when not using MPFR)
+  * Fixed add'l bug in MPFR functions, when specifying a rounding mode.
+  * Fixed memory bug when specifying an invalid precision, or base range.
+  * Fixed GMP::Z#pow (note that GMP::Z.pow has always worked.)
+  * Added many tests from MPFR's tsqrt.c. This actually exposed a lot of bugs in
+    the gem.
+  * Added GMP::Z.size (mpz_size). Not tested yet.
+  * Added GMP::Z.addmul! (mpz_addmul) with tests.
+  * Unit test results: 90 tests, 1500 assertions, 0 failures, 0 errors
+  * Unit test results: 79 tests, 742 assertions, 0 failures, 0 errors (w/o MPFR)
+
 0.4.7:
   * Added 6 MPFR trig methods, plus eint, li2, gamma, lngamma, zeta, erf, erfc,
     j0, j1, jn, y0, y1, and yn.

data/README.rdoc

@@ -87,6 +87,12 @@ as pi, are defined under class methods of GMP::F, listed below.
   GMP::GMP_RNDZ           #=> The constant representing "round toward zero"
   GMP::GMP_RNDU           #=> The constant representing "round toward plus infinity"
   GMP::GMP_RNDD           #=> The constant representing "round toward minus infinity"
+  New in MPFR 3.0.0:
+  GMP::MPFR_RNDN
+  GMP::MPFR_RNDZ
+  GMP::MPFR_RNDU
+  GMP::MPFR_RNDD
+  GMP::MPFR_RNDA          #=> The constant representing "round away from zero"
 
 =Classes
 
@@ -192,6 +198,7 @@ You can also call them as:
     popcount                 the number of bits equal to 1
     sizeinbase(b)            digits in base b
     size_in_bin              digits in binary
+    size                     number of limbs
     to_i                     convert to Fixnum or Bignum
   GMP::Q and GMP::F
     /                        division
@@ -226,6 +233,8 @@ You can also call them as:
     const_catalan            returns catalan
   GMP::F
     sqrt                     square root of the object
+    rec_sqrt                 square root of the recprical of the object
+    cbrt                     cube root of the object
     **                       power
     log                      natural logarithm of object
     log2                     binary logarithm of object
@@ -241,6 +250,7 @@ You can also call them as:
     li2                      real part of the dilogarithm of object
     gamma                    Gamma fucntion of object
     lngamma                  logarithm of the Gamma function of object
+    digamma                  Digamma function of object (MPFR_VERSION >= "3.0.0")
     zeta                     Reimann Zeta function of object
     erf                      error function of object
     erfc                     complementary error function of object
@@ -265,13 +275,14 @@ You can also call them as:
     sec                      |
     csc                      |
     cot                      |
-    aconh                    |
+    acosh                    |
     asinh                    |
     atanh                    /
     nan?                     \
     infinite?                | type of floating point number
     finite?                  |
-    number?                  /
+    number?                  |
+    regular?                 / (MPFR_VERSION >= "3.0.0")
   GMP::RandState
     mpfr_urandomb(fixnum)    get uniformly distributed random floating-point
                              number within 0 <= rop < 1
@@ -290,8 +301,6 @@ that is fixed with the unit_test gem.
 
 =Known Issues
 
-* GMP::Z#pow does not appear to be working at all. Looking at the code, I don't
-  think it ever did.
 * Don't call GMP::RandState(:lc_2exp_size). Give a 2nd arg.
 
 =Precision
@@ -380,11 +389,10 @@ efficiency in GMP; the inefficiencies of the gmp gem are relatively greater.
 =Todo
 
 These are inherited from Tomasz. I will go through these and see which are
-still relevant.
+still relevant, and which I understand.
 
 * mpz_fits_* and 31 vs. 32 integer variables
 * fix all sign issues (don't know what these are)
-* floats with precision control
 * to_s vs. inspect
 * check if mpz_addmul_ui would optimize some statements
 * some system that allows using denref and numref as normal ruby objects (?)
@@ -404,5 +412,5 @@ still relevant.
 * check if different sorting of operatations gives better cache usage
 * GMP::* op RubyFloat and RubyFloat op GMP::*
 * sort checks
-* GMP::Q.to_s(base), GMP::F.to_s(base)
-* benchmark gcdext, pi
+* GMP::Q.to_s(base), GMP::F.to_s(base) (test it!)
+* benchmark gcdext, pi

data/benchmark/multiply

@@ -41,4 +41,4 @@ while true
   f = f * 0.1
 end
 
-puts "RESULT: %#{decimals}f operations per second\n" % ops_per_sec
+puts "RESULT: %#{decimals}f operations per second\n" % ops_per_sec

data/benchmark/multiply.gc

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+
+require '../ext/gmp'
+
+multiplicands = ARGV
+random_state = GMP::RandState.new
+
+if multiplicands.size > 1
+  m, n = multiplicands[0].to_i, multiplicands[1].to_i
+  x = random_state.urandomb(m)
+  y = random_state.urandomb(n)
+else
+  m = multiplicands[0].to_i
+  x = random_state.urandomb(m)
+  y = x
+end
+
+t = GMP::time { z = x * y }
+iterations = (1 + (1e4 / t)).to_i
+
+if multiplicands.size > 1
+  print "Multiplying %i-bit number with %i-bit number %i times..." % [m, n, iterations]
+else
+  print "Squaring a %i-bit number %i times..." % [m, iterations]
+end
+STDOUT.flush
+
+t0 = GMP::cputime
+#iterations.times do
+#  z = x * y
+#end
+parts = 512
+foo = iterations / parts
+bar = iterations % parts
+foo.times do
+  parts.times do
+    z = x * y
+  end
+  GC.start
+end
+bar.times do
+  z = x * y
+end
+
+ti = GMP::cputime - t0
+  
+puts "done!"
+ops_per_sec = 1000.0 * iterations / ti
+f = 100.0
+decimals = 0
+while true
+  decimals += 1
+  break if ops_per_sec > f
+  f = f * 0.1
+end
+
+puts "RESULT: %#{decimals}f operations per second\n" % ops_per_sec

data/benchmark/pi

@@ -0,0 +1,126 @@
+#!/usr/bin/env ruby
+
+require '../ext/gmp'
+
+A = 13591409
+B = 545140134
+C = 640320
+D = 12
+
+BITS_PER_DIGIT  = 3.32192809488736234787
+DIGITS_PER_ITER = 14.1816474627254776555
+DOUBLE_PREC     = 53
+INIT_FACS       = 32
+
+def my_sqrt_ui(r, x)
+  prec0 = r.prec
+  if prec0 < DOUBLE_PREC
+    r = GMP::F(Math.sqrt(x))
+    return
+  end
+
+  bits = 0
+  prec = prec0
+  while prec > DOUBLE_PREC
+    bit = prec & 1
+    prec = (prec+bit)/2
+    bits = bits*2 + bit
+  end
+
+  @t1.prec_raw=DOUBLE_PREC
+  @t1 = GMP::F(1/Math.sqrt(x))
+
+  while prec < prec0
+    prec *= 2
+    break if prec >= prec0
+    @t2.prec_raw=prec
+    @t2 = @t1 * @t1       # half x half -> full
+    @t2 *= x
+    @t2 = 1 - @t2
+    @t2.prec_raw=prec/2
+    @t2.div_2exp(@t2, 1)
+    @t2 *= @t1            # half x half -> half
+    @t1.prec_raw=prec
+    @t1 += @t2
+
+    prec -= bits & 1
+    bits /= 2
+  end
+
+  @t2.prec_raw=prec0/2
+  @t2 = @t1 * x
+  r = @t2 * @t2         # half * half -> full
+  r = x - r
+  @t1 *= r              # half * half -> half
+  @t1.div_2exp(@t1, 1)
+  r = @t1+@t2
+end
+
+def my_div(r, y, x)
+  prec0 = r.prec
+  if prec0 <= DOUBLE_PREC
+    r = GMP::F(y.to_f / x.to_f)
+    return
+  end
+
+  bits = 0
+  prec = prec0
+  while prec > DOUBLE_PREC
+    bit = prec & 1
+    prec = (prec+bit)/2
+    bits = bits*2 + bit
+  end
+
+  @t1.prec_raw=DOUBLE_PREC
+  @t1 = 1 / x
+
+  while prec < prec0
+    prec *= 2
+    if prec < prec0
+      @t2.prec_raw=prec
+      @t2 = x * @t1        # full x half -> full
+      @t2 = 1 - @t2
+      @t2.prec_raw=prec/2
+      @t2 *= @t1           # half * half -> half
+      @t1.prec_raw=prec
+      @t1 += @t2
+    else
+      prec = prec0
+      @t2.prec_raw=prec/2
+      @t2 = @t1 * y        # half * half -> half
+      r = x * @t2          # full * half -> full
+      r = y - r
+      t1 *= r              # half * half -> half
+      r = t1 + t2
+      break
+    end
+
+    prec -= bits & 1
+    bits /= 2
+  end
+end
+
+def min(x,y); x < y ? x : y; end
+def max(x,y); x > y ? x : y; end
+
+Fac_t = Struct.new(max_facs, num_facs, fac, pow)
+Sieve_t = Struct.new(fac, pow, nxt);
+
+sieve = Sieve_t.new
+ftmp = Fac_t.new
+fmul = Fac_t.new
+
+def fac_show(f)
+  (0...(f.num_facs)).each do |f|
+    if f.pow[i] == 1
+      print "#{f.fac[i]} "
+    else
+      print "#{f.fac[i]}^#{f.pow[i]} "
+    end
+  end
+  puts ""
+end
+
+def fac_reset(f)
+  f.num_facs = 0
+end

data/benchmark/srb.sh

@@ -0,0 +1,21 @@
+#! /bin/bash
+source ~/.rvm/scripts/rvm
+
+if [ $# -gt 0 ]; then
+  rvm use $1
+  if [ $? -ne 0 ]; then
+    echo "ERROR: rvm doesn't like \"$1\". Quitting."
+    exit 1
+  fi
+fi
+
+LIBS=-lgmp ./runbench -n
+if [ $? -ne 0 ]; then
+  echo "ERROR: ruby extconf.rb didn't work so hot. Quitting."
+  exit 2
+fi
+
+echo "RUBY:   `ruby -v`"
+echo "GMP:    `ruby -r '../lib/gmp' -e \"puts GMP::GMP_VERSION\"`"
+echo "GMP_CC: `ruby -r '../lib/gmp' -e \"puts GMP::GMP_CC\"`"
+

data/ext/extconf.rb

@@ -5,6 +5,7 @@ require 'mkmf'
 dir_config('gmp')
 dir_config('mpfr')
 
+use_if_mpfr = ! ARGV.include?('--no-mpfr')
 ok = true
 unless have_header('gmp.h')
   $stderr.puts "can't find gmp.h, try --with-gmp-include=<path>"
@@ -16,11 +17,13 @@ unless have_library('gmp', '__gmpz_init')
   ok = false
 end
 
+if use_if_mpfr
 if (have_header('mpfr.h') and
     have_header('mpf2mpfr.h') and
     have_library('mpfr', 'mpfr_init'))
   $CFLAGS += ' -DMPFR'
 end
+end
 
 $CFLAGS += ' -Wall -W -O6 -g'
 if ok

data/ext/gmp.c

@@ -13,7 +13,11 @@ VALUE cGMP_Rnd;
 
 void r_gmpz_free(void *ptr)         { mpz_clear (ptr);     free (ptr); }
 void r_gmpq_free(void *ptr)         { mpq_clear (ptr);     free (ptr); }
+#ifdef MPFR
+void r_gmpf_free(void *ptr)         { mpfr_clear (ptr);     free (ptr); }
+#else
 void r_gmpf_free(void *ptr)         { mpf_clear (ptr);     free (ptr); }
+#endif
 void r_gmprandstate_free(void *ptr) { gmp_randclear (ptr); free (ptr); }
 
 static void mpq_str_set(MP_RAT *ROP, char *str)
@@ -46,7 +50,7 @@ static VALUE r_gmpq_initialize(int argc, VALUE *argv, VALUE self)
       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, STR2CSTR(argv[0]));
+      mpq_str_set (self_val, StringValuePtr(argv[0]));
     } else {
       mpz_set_value (mpq_numref(self_val), argv[0]);
       if (argc == 2) {
@@ -83,10 +87,10 @@ static VALUE r_gmpfsg_set_default_prec(VALUE klass, VALUE arg)
 {
   (void)klass;
   if (FIXNUM_P(arg)) {
-    if (FIX2INT(arg) <= 0) {
+    if (FIX2NUM(arg) <= 0) {
       rb_raise(rb_eRangeError, "prec must be positive");
     }
-    mpf_set_default_prec (FIX2INT(arg));
+    mpf_set_default_prec (FIX2NUM(arg));
   } else {
     rb_raise(rb_eTypeError, "prec must be FixNum");
   }
@@ -133,6 +137,11 @@ static VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
     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;
@@ -160,6 +169,10 @@ mp_rnd_t r_get_rounding_mode(VALUE rnd)
       return GMP_RNDU;
     case 3:
       return GMP_RNDD;
+#if MPFR_VERSION_MAJOR>2
+    case 4:
+      return MPFR_RNDA;
+#endif
     default:
       return GMP_RNDN;
   }
@@ -188,10 +201,6 @@ void Init_gmp() {
   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));
-  // rb_define_const(mGMP, "GMP_RNDN", INT2FIX(0));
-  // rb_define_const(mGMP, "GMP_RNDZ", INT2FIX(1));
-  // rb_define_const(mGMP, "GMP_RNDU", INT2FIX(2));
-  // rb_define_const(mGMP, "GMP_RNDD", INT2FIX(3));
 #endif /* MPFR */
 
   cGMP_Z = rb_define_class_under(mGMP, "Z", rb_cInteger);

data/ext/gmpbench_timing.c

@@ -41,7 +41,7 @@ cputime ()
   struct rusage rus;
 
   getrusage (0, &rus);
-  return rus.ru_utime.tv_sec * 1000 + rus.ru_utime.tv_usec / 1000;
+  return (int) (rus.ru_utime.tv_sec * 1000 + rus.ru_utime.tv_usec / 1000);
 }
 #endif
 

data/ext/gmpf.c

@@ -72,8 +72,8 @@ VALUE r_gmpfsg_new(int argc, VALUE *argv, VALUE klass)
   VALUE res;
   (void)klass;
 
-  if (argc > 2)
-    rb_raise(rb_eArgError, "wrong # of arguments(%d for 0, 1 or 2)", argc);
+  if (argc > 4)
+    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);
@@ -90,30 +90,68 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
   mpf_get_struct (self, self_val);
 
   if (argc==0) {
-    mpf_init(self_val);
-    mpf_set_si(self_val, 0);
+#ifdef MPFR
+    mpfr_init (self_val);
+    mpfr_set_si (self_val, 0, __gmp_default_rounding_mode);
+#else
+    r_mpf_init (self_val);
+    mpf_set_si (self_val, 0);
+#endif
     return Qnil;
   }
 
   arg = argv[0];
 
-  if (argc == 2) {
+  //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
+      else {
+        r_mpf_init (self_val);
         rb_raise(rb_eRangeError, "prec must be non-negative");
+      }
     } else {
+      r_mpf_init (self_val);
       rb_raise(rb_eTypeError, "prec must be a Fixnum");
     }
   } else if (GMPF_P(arg)) {
     mpf_get_struct (arg, arg_val_f);
     prec = mpf_get_prec (arg_val_f);
   }
+#ifdef MPFR
+  int base = 10;
   if (prec == 0)
-    mpf_init (self_val);
+    mpfr_init (self_val);
   else
-    mpf_init2 (self_val, prec);
+    mpfr_init2 (self_val, prec);
+  
+  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 {
+        rb_raise(rb_eTypeError, "base must be a Fixnum");
+      }
+    }
+    if (argc == 4) {
+      // FIGURE IT OUT. ACCEPT A ROUNDING MODE!
+    }
+    
+    mpf_set_value2 (self_val, arg, base);
+    return Qnil;
+  }
+
+#else
+  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);
@@ -130,32 +168,71 @@ void mpf_set_value(MP_FLOAT *self_val, VALUE arg)
 {
   MP_RAT *arg_val_q;
   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 (FIXNUM_P(arg)) {
+    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 (result == -1) {
+      rb_raise(rb_eRuntimeError, "Badly formatted string");
+    }
+  } 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);
-    mpf_set_q(self_val, arg_val_q);
+    r_mpf_set_q(self_val, arg_val_q);
   } else if (GMPZ_P(arg)) {
     mpz_get_struct(arg, arg_val_z);
-    mpf_set_z(self_val, arg_val_z);
+    r_mpf_set_z(self_val, arg_val_z);
   } else if (FLOAT_P(arg)) {
-    mpf_set_d(self_val, NUM2DBL(arg));
+    r_mpf_set_d(self_val, NUM2DBL(arg));
   } else if (FIXNUM_P(arg)) {
-    mpf_set_si(self_val, FIX2INT(arg));
+    mpf_set_si(self_val, FIX2NUM(arg));
   } else if (STRING_P(arg)) {
-    if (mpf_set_str(self_val, STR2CSTR(arg), 10) == -1) {
+    result = r_mpf_set_str(self_val, StringValuePtr(arg), 10);
+    if (result == -1) {
       rb_raise(rb_eRuntimeError, "Badly formatted string");
     }
   } else if (BIGNUM_P(arg)) {
 #if 1 /* GMP3 code */
     mpz_temp_from_bignum(arg_val_z, arg);
-    mpf_set_z(self_val, arg_val_z);
+    r_mpf_set_z(self_val, arg_val_z);
     mpz_temp_free(arg_val_z);
+#endif
 #endif
   } else {
     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);
+  
+  if (result == -1) {
+    rb_raise(rb_eRuntimeError, "Badly formatted string");
+  }
+}
+#endif
+
 /*
  * call-seq:
  *   GMP::F(arg)
@@ -181,6 +258,48 @@ VALUE r_gmpf_to_d(VALUE self)
   return rb_float_new(mpf_get_d(self_val));
 }
 
+#ifdef MPFR
+/*
+ * Document-method: to_s
+ *
+ * call-seq:
+ *   float.to_s
+ *
+ * Returns the decimal representation of +float+, 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);
+  
+  //mpfr_sprintf(str, "%Rf", self_val);
+  //res = rb_str_new2(str);
+  
+  str = mpfr_get_str(NULL, &exponent, 10, 0, self_val, __gmp_default_rounding_mode);
+  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);
+    mpfr_free_str(str2);
+  }
+  
+  mpfr_free_str(str);
+  return res;
+}
+#else
 /*
  * Document-method: to_s
  *
@@ -217,12 +336,14 @@ VALUE r_gmpf_to_s(VALUE self)
   free(str);
   return res;
 }
+#endif
 
 
 /**********************************************************************
  *    Float Arithmetic                                                *
  **********************************************************************/
 
+#ifndef MPFR
 /*
  * call-seq:
  *   float + other
@@ -241,7 +362,7 @@ VALUE r_gmpf_add(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);
 
@@ -266,7 +387,7 @@ VALUE r_gmpf_add(VALUE self, VALUE arg)
     mpf_add (res_val, res_val, self_val);
   } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
     mpf_make_struct_init(res, res_val, prec);
-    mpf_set_si (res_val, FIX2INT(arg));
+    mpf_set_si (res_val, FIX2NUM(arg));
     mpf_add (res_val, res_val, self_val);
   } else if (BIGNUM_P(arg)) {
     mpz_temp_from_bignum(arg_val_z, arg);
@@ -280,6 +401,72 @@ VALUE r_gmpf_add(VALUE self, VALUE arg)
 
   return res;
 }
+#else
+/*
+ * call-seq:
+ *   float + other
+ *
+ * Returns the sum of +float+ and +other+. +other+ can be
+ * * GMP::Z
+ * * Fixnum
+ * * GMP::Q
+ * * GMP::F
+ * * Bignum
+ * * Float
+ */
+#define DEFUN_F_ZQXFBD2F(fname)                                 \
+VALUE r_gmpfr_##fname(int argc, VALUE *argv, VALUE self)        \
+{                                                               \
+  MP_FLOAT *self_val, *res_val, *arg_val_f;                     \
+  MP_RAT *arg_val_q;                                            \
+  MP_INT *arg_val_z;                                            \
+  VALUE arg, res, res_prec, rnd_mode;                           \
+  mpfr_prec_t prec, res_prec_val;                               \
+  mp_rnd_t rnd_mode_val;                                        \
+                                                                \
+  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_val = __gmp_default_rounding_mode; }    \
+  else { rnd_mode_val = r_get_rounding_mode(rnd_mode); }        \
+  if (NIL_P (res_prec)) { res_prec_val = prec; }                \
+  else { res_prec_val = FIX2INT (res_prec); }                   \
+  mpf_make_struct_init (res, res_val, res_prec_val);            \
+                                                                \
+  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_##fname (res_val, self_val, arg_val_f, rnd_mode_val);  \
+  } else if (GMPQ_P (arg)) {                                    \
+    mpq_get_struct (arg, arg_val_q);                            \
+    mpf_make_struct_init (res, res_val, prec);                  \
+    mpfr_##fname##_q (res_val, self_val, arg_val_q, rnd_mode_val);  \
+  } else if (GMPZ_P (arg)) {                                    \
+    mpz_get_struct (arg, arg_val_z);                            \
+    mpf_make_struct_init (res, res_val, prec);                  \
+    mpfr_##fname##_z (res_val, self_val, arg_val_z, rnd_mode_val);  \
+  } else if (FLOAT_P (arg)) {                                   \
+    mpf_make_struct_init (res, res_val, prec);                  \
+    mpfr_##fname##_d (res_val, self_val, NUM2DBL (arg), rnd_mode_val);  \
+  } else if (FIXNUM_P (arg)) {                                  \
+    mpf_make_struct_init(res, res_val, prec);                   \
+    mpfr_##fname##_si (res_val, self_val, FIX2NUM (arg), rnd_mode_val);  \
+  } else if (BIGNUM_P (arg)) {                                  \
+    mpz_temp_from_bignum(arg_val_z, arg);                       \
+    mpf_make_struct_init(res, res_val, prec);                   \
+    mpfr_##fname##_z (res_val, self_val, arg_val_z, rnd_mode_val);  \
+    mpz_temp_free (arg_val_z);                                  \
+  } else {                                                      \
+    typeerror(ZQFXBD);                                          \
+  }                                                             \
+                                                                \
+  return res;                                                   \
+}
+
+DEFUN_F_ZQXFBD2F(add)
+DEFUN_F_ZQXFBD2F(mul)
+#endif
 
 /*
  * call-seq:
@@ -299,7 +486,7 @@ VALUE r_gmpf_sub(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);
 
@@ -324,7 +511,7 @@ VALUE r_gmpf_sub(VALUE self, VALUE arg)
     mpf_sub(res_val, self_val, res_val);
   } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
     mpf_make_struct_init(res, res_val, prec);
-    mpf_set_si(res_val, FIX2INT(arg));
+    mpf_set_si(res_val, FIX2NUM(arg));
     mpf_sub(res_val, self_val, res_val);
   } else if (BIGNUM_P(arg)) {
     mpz_temp_from_bignum(arg_val_z, arg);
@@ -357,7 +544,8 @@ VALUE r_gmpf_mul(VALUE self, VALUE arg)
   MP_RAT *arg_val_q;
   MP_INT *arg_val_z;
   VALUE res;
-  unsigned long prec;
+  //unsigned long prec;
+  mpfr_prec_t prec;
 
   mpf_get_struct_prec (self, self_val, prec);
 
@@ -382,7 +570,7 @@ VALUE r_gmpf_mul(VALUE self, VALUE arg)
     mpf_mul(res_val, self_val, res_val);
   } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
     mpf_make_struct_init(res, res_val, prec);
-    mpf_set_si(res_val, FIX2INT(arg));
+    mpf_set_si(res_val, FIX2NUM(arg));
     mpf_mul(res_val, self_val, res_val);
   } else if (BIGNUM_P(arg)) {
     mpz_temp_from_bignum(arg_val_z, arg);
@@ -397,6 +585,92 @@ VALUE r_gmpf_mul(VALUE self, VALUE arg)
   return res;
 }
 
+/*
+ * call-seq:
+ *   float ** integer
+ *
+ * Returns +float+ raised to the +integer+ power. +integer+ must be
+ * * Fixnum or Bignum
+ * * non-negative
+ */
+VALUE r_gmpf_pow(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val, *res_val;
+  VALUE res;
+  
+  //unsigned long prec;
+  mpfr_prec_t prec;
+
+  mpf_get_struct_prec (self, self_val, prec);
+
+  if (FIXNUM_P(arg)) {
+    if (FIX2NUM(arg) >= 0) {
+      mpf_make_struct_init(res, res_val, prec);
+      mpf_pow_ui(res_val, self_val, FIX2NUM(arg));
+    } else {
+      rb_raise(rb_eRangeError, "power must be non-negative");
+    }
+  } else {
+    typeerror(X);
+  }
+
+  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
@@ -415,7 +689,7 @@ VALUE r_gmpf_div(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);
 
@@ -440,7 +714,7 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
     mpf_div(res_val, self_val, res_val);
   } else if (FIXNUM_P(arg)) { // _ui with sign control instead ?
     mpf_make_struct_init(res, res_val, prec);
-    mpf_set_si(res_val, FIX2INT(arg));
+    mpf_set_si(res_val, FIX2NUM(arg));
     mpf_div(res_val, self_val, res_val);
   } else if (BIGNUM_P(arg)) {
     mpz_temp_from_bignum(arg_val_z, arg);
@@ -455,6 +729,8 @@ VALUE r_gmpf_div(VALUE self, VALUE arg)
   return res;
 }
 
+
+
 /*
  * Document-method: neg
  *
@@ -507,11 +783,11 @@ int mpf_cmp_value(MP_FLOAT *self_val, VALUE arg)
 
   if (GMPF_P(arg)) {
     mpf_get_struct(arg,arg_val);
-    return mpf_cmp (self_val, arg_val);
+    return r_mpf_cmp (self_val, arg_val);
   } else {
     mpf_temp_init(arg_val, mpf_get_prec (self_val));
     mpf_set_value (arg_val, arg);
-    result = mpf_cmp (self_val, arg_val);
+    result = r_mpf_cmp (self_val, arg_val);
     mpf_temp_free(arg_val);
     return result;
   }
@@ -529,8 +805,8 @@ VALUE r_gmpf_cmp(VALUE self, VALUE arg)
 {
   MP_FLOAT *self_val;
   int res;
-  mpf_get_struct(self,self_val);
-  res = mpf_cmp_value(self_val, arg);
+  mpf_get_struct (self, self_val);
+  res = mpf_cmp_value (self_val, arg);
   if (res > 0)
     return INT2FIX(1);
   else if (res == 0)
@@ -547,26 +823,26 @@ DEFUN_FLOAT_CMP(ge,>=)
 
 #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;                                        \
-  unsigned long prec, res_prec_value;                              \
-  mp_rnd_t rnd_mode_value;                                         \
-  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_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);             \
-  mpfr_##name (res_val, self_val, __gmp_default_rounding_mode);    \
-                                                                   \
-  return res;                                                      \
+#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;                                    \
+  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; }    \
+  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, self_val, rnd_mode_val);               \
+                                                               \
+  return res;                                                  \
 }
 
 #define MPFR_SINGLE_1ARG_FUNCTION(name)                            \
@@ -574,7 +850,7 @@ VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)            \
 {                                                                  \
   MP_FLOAT *self_val, *res_val;                                    \
   VALUE arg1, res_prec;                                            \
-  unsigned long prec, arg1_val, res_prec_value;                    \
+  mpfr_prec_t prec, arg1_val, res_prec_value;                      \
   VALUE res;                                                       \
                                                                    \
   rb_scan_args (argc, argv, "11", &arg1, &res_prec);               \
@@ -590,6 +866,19 @@ VALUE r_gmpfr_##name(int argc, VALUE *argv, VALUE self)            \
   return res;                                                      \
 }
 
+#define MPFR_SINGLE_BOOLEAN_FUNCTION(name)  \
+static VALUE r_gmpfr_##name(VALUE self)     \
+{                                           \
+  MP_FLOAT *self_val;                       \
+                                            \
+  mpf_get_struct(self, self_val);           \
+  if (mpfr_##name (self_val))               \
+    return Qtrue;                           \
+  else                                      \
+    return Qfalse;                          \
+}
+
+
 #define MPFR_CONST_FUNCTION(name)                        \
 VALUE r_gmpfrsg_##name()                                 \
 {                                                        \
@@ -604,6 +893,8 @@ VALUE r_gmpfrsg_##name()                                 \
 }
 
 MPFR_SINGLE_FUNCTION(sqrt)
+MPFR_SINGLE_FUNCTION(rec_sqrt)
+MPFR_SINGLE_FUNCTION(cbrt)
 
 MPFR_SINGLE_FUNCTION(log)
 MPFR_SINGLE_FUNCTION(log2)
@@ -640,6 +931,9 @@ MPFR_SINGLE_FUNCTION(li2)
 MPFR_SINGLE_FUNCTION(gamma)
 MPFR_SINGLE_FUNCTION(lngamma)
 /*MPFR_SINGLE_FUNCTION(lgamma)*/
+#if MPFR_VERSION_MAJOR > 2
+MPFR_SINGLE_FUNCTION(digamma)
+#endif
 MPFR_SINGLE_FUNCTION(zeta)
 MPFR_SINGLE_FUNCTION(erf)
 MPFR_SINGLE_FUNCTION(erfc)
@@ -655,32 +949,8 @@ MPFR_CONST_FUNCTION(const_pi)
 MPFR_CONST_FUNCTION(const_euler)
 MPFR_CONST_FUNCTION(const_catalan)
 
-static VALUE r_gmpfr_nan_p(VALUE self)
-{
-  MP_FLOAT *self_val;
-
-  mpf_get_struct(self, self_val);
-  if (mpfr_nan_p(self_val)) {
-    return Qtrue;
-  }
-  else {
-    return Qfalse;
-  }
-}
-
-static VALUE r_gmpfr_inf_p(VALUE self)
-{
-  MP_FLOAT *self_val;
-
-  mpf_get_struct(self, self_val);
-  if (mpfr_inf_p(self_val)) {
-    return Qtrue;
-  }
-  else {
-    return Qfalse;
-  }
-}
-
+MPFR_SINGLE_BOOLEAN_FUNCTION(nan_p)
+MPFR_SINGLE_BOOLEAN_FUNCTION(inf_p)
 static VALUE r_gmpfr_fin_p(VALUE self)
 {
   if (r_gmpfr_inf_p(self)) {
@@ -690,26 +960,18 @@ static VALUE r_gmpfr_fin_p(VALUE self)
     return Qtrue;
   }
 }
-
-static VALUE r_gmpfr_number_p(VALUE self)
-{
-  MP_FLOAT *self_val;
-
-  mpf_get_struct(self, self_val);
-  if (mpfr_number_p(self_val)) {
-    return Qtrue;
-  }
-  else {
-    return Qfalse;
-  }
-}
+MPFR_SINGLE_BOOLEAN_FUNCTION(number_p)
+MPFR_SINGLE_BOOLEAN_FUNCTION(zero_p)
+#if MPFR_VERSION_MAJOR > 2
+MPFR_SINGLE_BOOLEAN_FUNCTION(regular_p)
+#endif
 
 static VALUE r_gmpfr_pow(VALUE self, VALUE arg)
 {
   MP_FLOAT *self_val, *res_val, *arg_val_f;
   MP_RAT *arg_val_q;
   MP_INT *arg_val_z;
-  unsigned long prec;
+  mpfr_prec_t prec;
   VALUE res;
 
   mpf_get_struct_prec(self, self_val, prec);
@@ -743,7 +1005,6 @@ static VALUE r_gmpfr_pow(VALUE self, VALUE arg)
     } else {
       typeerror(ZQFXBD);
     }
-
   }
 
   return res;
@@ -771,15 +1032,39 @@ DEFUN_FLOAT2FLOAT(ceil,mpf_ceil)
 VALUE r_gmpf_sgn(VALUE self)
 {
   MP_FLOAT *self_val;
-  mpf_get_struct(self, self_val);
-  return INT2FIX(mpf_sgn(self_val));
+  mpf_get_struct (self, self_val);
+  return INT2FIX (mpf_sgn (self_val));
 }
 
 VALUE r_gmpf_get_prec(VALUE self)
 {
   MP_FLOAT *self_val;
-  mpf_get_struct(self, self_val);
-  return INT2NUM(mpf_get_prec(self_val));
+  mpf_get_struct (self, self_val);
+  return INT2NUM (mpf_get_prec (self_val));
+}
+
+VALUE r_gmpf_set_prec(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val;
+  if (FIXNUM_P(arg)) {
+    mpf_get_struct (self, self_val);
+    mpf_set_prec (self_val, FIX2NUM (arg));
+    return Qnil;
+  } else {
+    typeerror(X);
+  }
+}
+
+VALUE r_gmpf_set_prec_raw(VALUE self, VALUE arg)
+{
+  MP_FLOAT *self_val;
+  if (FIXNUM_P(arg)) {
+    mpf_get_struct (self, self_val);
+    mpf_set_prec_raw (self_val, FIX2NUM (arg));
+    return Qnil;
+  } else {
+    typeerror(X);
+  }
 }
 
 
@@ -794,6 +1079,9 @@ 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);
+  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);
   
   // Converting Floats
   rb_define_method(cGMP_F, "to_s", r_gmpf_to_s, 0);
@@ -801,10 +1089,18 @@ void init_gmpf()
   rb_define_alias(cGMP_F, "to_f", "to_d");
   
   // Float Arithmetic
-  rb_define_method(cGMP_F, "+", r_gmpf_add, 1);
   rb_define_method(cGMP_F, "-", r_gmpf_sub, 1);
-  rb_define_method(cGMP_F, "*", r_gmpf_mul, 1);
   rb_define_method(cGMP_F, "/", r_gmpf_div, 1);
+#ifndef MPFR
+  rb_define_method(cGMP_F, "+", r_gmpf_add, 1);
+  rb_define_method(cGMP_F, "*", r_gmpf_mul, 1);
+  rb_define_method(cGMP_F, "**", r_gmpf_pow, 1);
+  rb_define_alias(cGMP_F, "pow", "**");
+#else
+  rb_define_method(cGMP_F, "+", r_gmpfr_add, -1);
+  rb_define_method(cGMP_F, "*", r_gmpfr_mul, -1);
+  rb_define_method(cGMP_F, "**", r_gmpfr_pow, 1);
+#endif
   rb_define_method(cGMP_F, "-@", r_gmpf_neg, 0);
   rb_define_method(cGMP_F, "neg!", r_gmpf_neg_self, 0);
   rb_define_method(cGMP_F, "abs", r_gmpf_abs, 0);
@@ -817,18 +1113,53 @@ void init_gmpf()
   rb_define_method(cGMP_F, "<",   r_gmpf_cmp_lt, 1);
   rb_define_method(cGMP_F, "<=",  r_gmpf_cmp_le, 1);
   rb_define_method(cGMP_F, "==",  r_gmpf_eq, 1);
+  rb_define_method(cGMP_F, "sgn", r_gmpf_sgn, 0);
+  
+  // Miscellaneous Functions
+  rb_define_method(cGMP_F, "ceil",  r_gmpf_ceil, 0);
+  rb_define_method(cGMP_F, "ceil!",  r_gmpf_ceil_self, 0);
+  rb_define_method(cGMP_F, "floor",  r_gmpf_floor, 0);
+  rb_define_method(cGMP_F, "floor!",  r_gmpf_floor_self, 0);rb_define_method(cGMP_F, "trunc",  r_gmpf_trunc, 0);
+  rb_define_method(cGMP_F, "trunc!",  r_gmpf_trunc_self, 0);
+  
   
 #ifdef MPFR
+  /* To implement; new in MPFR 3.0.0:
+   *
+   * mpfr_buildopt_tls_p
+   * mpfr_buildopt_decimal_p
+   * mpfr_set_zero
+   * mpfr_ai
+   * mpfr_set_flt
+   * mpfr_get_flt
+   * mpfr_urandom
+   * mpfr_set_z_2exp
+   */
   // Basic Arithmetic Functions
-  rb_define_method(cGMP_F, "sqrt", r_gmpfr_sqrt, -1);
+  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);
+  //rb_define_method(cGMP_F, "**", r_gmpfr_pow, 1);
   
   // Comparison Functions
   rb_define_method(cGMP_F, "nan?", r_gmpfr_nan_p, 0);
   rb_define_method(cGMP_F, "infinite?", r_gmpfr_inf_p, 0);
   rb_define_method(cGMP_F, "finite?", r_gmpfr_fin_p, 0);
   rb_define_method(cGMP_F, "number?", r_gmpfr_number_p, 0);
+  rb_define_method(cGMP_F, "zero?", r_gmpfr_zero_p, 0);
+#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
   
   // Special Functions
   rb_define_method(cGMP_F, "log",   r_gmpfr_log,   -1);
@@ -840,6 +1171,7 @@ void init_gmpf()
   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);
@@ -847,10 +1179,13 @@ void init_gmpf()
   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);
@@ -859,6 +1194,8 @@ 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_method(cGMP_F, "log1p",   r_gmpfr_log1p,   -1);
   rb_define_method(cGMP_F, "expm1",   r_gmpfr_expm1,   -1);
   rb_define_method(cGMP_F, "eint",    r_gmpfr_eint,    -1);
@@ -866,6 +1203,9 @@ void init_gmpf()
   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);*/
+#if MPFR_VERSION_MAJOR > 2
+  rb_define_method(cGMP_F, "digamma", r_gmpfr_digamma, -1);
+#endif
   rb_define_method(cGMP_F, "zeta", r_gmpfr_zeta,       -1);
   rb_define_method(cGMP_F, "erf", r_gmpfr_erf,         -1);
   rb_define_method(cGMP_F, "erfc", r_gmpfr_erfc,       -1);
@@ -875,20 +1215,21 @@ void init_gmpf()
   rb_define_method(cGMP_F, "y0", r_gmpfr_y0,           -1);
   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
+  // "agm", r_gmpfr_agm
+  // "hypot", r_gmpfr_hypot
+  // "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);
+
+  // Integer and Remainder Related Functions
+  // "integer?", r_gmpfr_integer_p
 #endif /* MPFR */
   
   // _unsorted_
-  rb_define_method(cGMP_F, "floor",  r_gmpf_floor, 0);
-  rb_define_method(cGMP_F, "floor!",  r_gmpf_floor_self, 0);
-  rb_define_method(cGMP_F, "ceil",  r_gmpf_ceil, 0);
-  rb_define_method(cGMP_F, "ceil!",  r_gmpf_ceil_self, 0);
-  rb_define_method(cGMP_F, "trunc",  r_gmpf_trunc, 0);
-  rb_define_method(cGMP_F, "trunc!",  r_gmpf_trunc_self, 0);
-  rb_define_method(cGMP_F, "sgn", r_gmpf_sgn, 0);
-  rb_define_method(cGMP_F, "prec", r_gmpf_get_prec, 0);
 }