gmp 0.4.1 → 0.4.3

data/CHANGELOG

@@ -1,6 +1,20 @@
+0.4.3:
+  * Support for MPFR on Windows introduced. gmp-x86-mswin32 gem should be used.
+  * Removed compilation warnings when using MPFR
+  * Added constants GMP::GMP_CC, GMP::GMP_CFLAGS, and GMP::GMP_BITS_PER_LIMB.
+  * Added constant GMP::MPFR_VERSION.
+  * Added MPFR rounding constants. These will be changed soon though.
+  * Added MPFR tests adapted straight from the MPFR library, just tsqrt so far.
+  * Added 3x MPFR functions: sec(), csc(), cot().
+  * Added function existence tests from
+  * Unit test results: 78 tests, 1025 assertions, 0 failures, 0 errors
+  * Unit test results: 72 tests, 593 assertions, 0 failures, 0 errors  (w/o MPFR)
+
 0.4.1:
   * Fixed some gem dates
+  * Fixed gmp.so in x86-mswin32 gem
   * Added urandomm(), documentation, and tests.
+  * Unit test results: 70 tests, 577 assertions, 0 failures, 0 errors
 
 0.4.0:
   * Support for Windows introduced. gmp-x86-mswin32 gem should be used.

data/README.rdoc

@@ -63,7 +63,8 @@ by me: gmp gem 0.4.0 on:
   |                                     | (MRI) Ruby 1.9.1  |           |
   +-------------------------------------+-------------------+-----------+
 
-<b>Note:</b> To get this running on Mac OS X (32-bit), I compiled GMP 4.3.1 with:
+<b>Note:</b> To get this running on Mac OS X (32-bit), I compiled GMP 4.3.1
+with:
   ./configure ABI=32 --disable-dependency-tracking
 
 =Authors
@@ -71,9 +72,25 @@ by me: gmp gem 0.4.0 on:
 * Tomasz Wegrzanowski
 * srawlins
 
+=Constants
+
+The GMP module includes the following constants. Mathematical constants, such
+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
+  (if MPFR is available)
+  GMP::MPFR_VERSION       #=> A string like "2.4.2"
+  GMP::GMP_RNDN           #=> The constant representing "round to nearest"
+  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"
+
 =Classes
 
-The module GMP is provided with following classes:
+The GMP module is provided with following classes:
 * GMP::Z - infinite precision integer numbers
 * GMP::Q - infinite precision rational numbers
 * GMP::F - arbitrary precision floating point numbers
@@ -190,19 +207,39 @@ You can also call them as:
     prec                     get precision
     floor,ceil,trunc         nearest integer, GMP::F is returned, not GMP::Z
     floor!,ceil!,trunc!      in-place nearest integer
-  GMP::F (only if MPFR is available)
-    exp                      e^object
-    expm1                    the same as (object.exp) - 1, with better
-                             precision
+  GMP::RandState
+    seed(integer)            seed the generator with a Fixnum or GMP::Z
+    urandomb(fixnum)         get uniformly distributed random number between 0
+                             and 2^fixnum-1, inclusive
+    urandomm(integer)        get uniformly distributed random number between 0
+                             and integer-1, inclusive
+  GMP (timing functions for GMPbench (0.2))
+    cputime                  milliseconds of cpu time since Ruby start
+    time                     times the execution of a block
+  
+  *only if MPFR is available*
+  class methods of GMP::F
+    const_log2               returns the natural log of 2
+    const_pi                 returns pi
+    const_euler              returns euler
+    const_catalan            returns catalan
+  GMP::F
+    sqrt                     square root of the object
+    **                       power
     log                      natural logarithm of object
     log2                     binary logarithm of object
     log10                    decimal logarithm of object
+    exp                      e^object
     log1p                    the same as (object + 1).log, with better
                              precision
-    sqrt                     square root of the object
+    expm1                    the same as (object.exp) - 1, with better
+                             precision
     cos                      \
     sin                      |
     tan                      |
+    sec                      |
+    csc                      |
+    cot                      |
     acos                     |
     asin                     |
     atan                     | trigonometric functions
@@ -216,14 +253,9 @@ You can also call them as:
     infinite?                | type of floating point number
     finite?                  |
     number?                  /
-    **                       power
   GMP::RandState
-    seed(integer)            seed the generator with a Fixnum or GMP::Z
-    urandomb(fixnum)         get uniformly distributed random number between 0
-                             and 2^fixnum-1, inclusive
-  GMP (timing functions for GMPbench (0.2))
-    cputime                  milliseconds of cpu time since Ruby start
-    time                     times the execution of a block
+    mpfr_urandomb(fixnum)    get uniformly distributed random floating-point
+                             number within 0 <= rop < 1
     
 
 =Testing
@@ -251,8 +283,9 @@ If there is no explicit precision, highest precision of all GMP::F arguments is
 used. That doesn't ensure that result will be exact. For details, consult any
 paper about floating point arithmetics.
 
-Default precision can be explicitely set by passing 0 to GMP::F.new(). In
-particular, you can set precision of copy of GMP::F object by:
+Default precision can be explicitely set by passing 0 as the second argument
+for to GMP::F.new(). In particular, you can set precision of copy of GMP::F
+object by:
   new_obj = GMP::F.new(old_obj, 0)
 
 Precision argument, and default_precision will be rounded up to whatever GMP
@@ -331,7 +364,6 @@ These are inherited from Tomasz. I will go through these and see which are
 still relevant.
 
 * mpz_fits_* and 31 vs. 32 integer variables
-* all appropriate module and class methods if there are any to add
 * fix all sign issues (don't know what these are)
 * floats with precision control
 * to_s vs. inspect

data/ext/gmp.c

@@ -121,6 +121,51 @@ static VALUE r_gmpfsg_set_default_prec(VALUE klass, VALUE arg)
   return Qnil;
 }
 
+#ifdef MPFR
+static VALUE r_gmpfsg_get_default_rounding_mode(VALUE klass)
+{
+  (void)klass;
+  const char *rounding_string_val;
+  VALUE rounding_string;
+  ID method_to_sym = rb_intern("to_sym");
+  rounding_string_val = mpfr_print_rnd_mode (mpfr_get_default_rounding_mode ());
+  rounding_string = rb_str_new2 (rounding_string_val);
+  /*return rb_const_get (mGMP, rb_intern (rounding_string));*/
+  return rb_funcall (rounding_string, method_to_sym, 0);
+}
+
+static VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
+{
+  (void)klass;
+  int arg_val;
+  if (FIXNUM_P(arg)) {
+    arg_val = FIX2INT(arg);
+    if (arg_val < 0 || arg_val > 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 (arg_val) {
+    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;
+  }
+  
+  return Qnil;
+}  
+#endif /* MPFR */
+
 #include "gmpf.h"
 #include "gmpq.h"
 /* #include "gmpz.h" */
@@ -135,6 +180,18 @@ static VALUE r_gmpfsg_set_default_prec(VALUE klass, VALUE arg)
 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_BITS_PER_LIMB", INT2FIX(mp_bits_per_limb));
+#ifdef MPFR
+  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);
   init_gmpz();
@@ -149,8 +206,12 @@ void Init_gmp() {
 
   cGMP_F = rb_define_class_under (mGMP, "F", rb_cNumeric);
   init_gmpf();
-  rb_define_singleton_method(cGMP_F, "default_prec", r_gmpfsg_get_default_prec, 0);
-  rb_define_singleton_method(cGMP_F, "default_prec=", r_gmpfsg_set_default_prec, 1);
+  rb_define_singleton_method (cGMP_F, "default_prec", r_gmpfsg_get_default_prec, 0);
+  rb_define_singleton_method (cGMP_F, "default_prec=", r_gmpfsg_set_default_prec, 1);
+#ifdef MPFR
+  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);
+#endif /* MPFR */
   rb_define_method(cGMP_F, "coerce", r_gmpf_coerce, 1); // new method - testing
 
 /*  rb_define_method(cGMP_F, "cmpabs",  r_gmpf_cmpabs, 1);*/
@@ -160,34 +221,6 @@ void Init_gmp() {
   
   init_gmpbench_timing();
 
-#ifdef MPFR
-  rb_define_method(cGMP_F, "exp", r_gmpfr_exp, 0);
-  rb_define_method(cGMP_F, "log", r_gmpfr_log, 0);
-  rb_define_method(cGMP_F, "sqrt", r_gmpfr_sqrt, 0);
-  rb_define_method(cGMP_F, "cos", r_gmpfr_cos, 0);
-  rb_define_method(cGMP_F, "sin", r_gmpfr_sin, 0);
-  rb_define_method(cGMP_F, "tan", r_gmpfr_tan, 0);
-  rb_define_method(cGMP_F, "acos", r_gmpfr_acos, 0);
-  rb_define_method(cGMP_F, "asin", r_gmpfr_asin, 0);
-  rb_define_method(cGMP_F, "atan", r_gmpfr_atan, 0);
-  rb_define_method(cGMP_F, "cosh", r_gmpfr_cosh, 0);
-  rb_define_method(cGMP_F, "sinh", r_gmpfr_sinh, 0);
-  rb_define_method(cGMP_F, "tanh", r_gmpfr_tanh, 0);
-  rb_define_method(cGMP_F, "acosh", r_gmpfr_acosh, 0);
-  rb_define_method(cGMP_F, "asinh", r_gmpfr_asinh, 0);
-  rb_define_method(cGMP_F, "atanh", r_gmpfr_atanh, 0);
-  rb_define_method(cGMP_F, "log1p", r_gmpfr_log1p, 0);
-  rb_define_method(cGMP_F, "expm1", r_gmpfr_expm1, 0);
-  rb_define_method(cGMP_F, "log2", r_gmpfr_log2, 0);
-  rb_define_method(cGMP_F, "log10", r_gmpfr_log10, 0);
-
-  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, "**", r_gmpfr_pow, 1);
-#endif /* MPFR */
   // more
 
   REGISTER_TAKEOVER(and, "&", "old_and")

data/ext/gmpf.c

@@ -105,7 +105,7 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
       else
         rb_raise(rb_eRangeError, "prec must be non-negative");
     } else {
-      rb_raise(rb_eTypeError, "prec must be FixNum");
+      rb_raise(rb_eTypeError, "prec must be a Fixnum");
     }
   } else if (GMPF_P(arg)) {
     mpf_get_struct (arg, arg_val_f);
@@ -515,6 +515,166 @@ DEFUN_FLOAT_CMP(gt,>)
 DEFUN_FLOAT_CMP(ge,>=)
 
 
+#ifdef MPFR
+
+#define MPFR_SINGLE_FUNCTION(name)                                 \
+VALUE r_gmpfr_##name(VALUE self)                                   \
+{                                                                  \
+  MP_FLOAT *self_val, *res_val;                                    \
+  unsigned long prec;                                              \
+  VALUE res;                                                       \
+                                                                   \
+  mpf_get_struct_prec (self, self_val, prec);                      \
+  mpf_make_struct_init (res, res_val, prec);                       \
+  mpfr_##name (res_val, self_val, __gmp_default_rounding_mode);    \
+                                                                   \
+  return res;                                                      \
+}
+
+#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;                                            \
+}
+
+MPFR_SINGLE_FUNCTION(sqrt)
+
+MPFR_SINGLE_FUNCTION(log)
+MPFR_SINGLE_FUNCTION(log2)
+MPFR_SINGLE_FUNCTION(log10)
+MPFR_SINGLE_FUNCTION(exp)
+
+MPFR_SINGLE_FUNCTION(cos)
+MPFR_SINGLE_FUNCTION(sin)
+MPFR_SINGLE_FUNCTION(tan)
+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_FUNCTION(cosh)
+MPFR_SINGLE_FUNCTION(sinh)
+MPFR_SINGLE_FUNCTION(tanh)
+
+MPFR_SINGLE_FUNCTION(acosh)
+MPFR_SINGLE_FUNCTION(asinh)
+MPFR_SINGLE_FUNCTION(atanh)
+
+MPFR_SINGLE_FUNCTION(log1p)
+MPFR_SINGLE_FUNCTION(expm1)
+
+MPFR_CONST_FUNCTION(const_log2)
+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;
+  }
+}
+
+static VALUE r_gmpfr_fin_p(VALUE self)
+{
+  if (r_gmpfr_inf_p(self)) {
+    return Qfalse;
+  }
+  else {
+    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;
+  }
+}
+
+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;
+  VALUE res;
+
+  mpf_get_struct_prec(self, self_val, prec);
+
+  if (GMPF_P(arg)) {
+    mpf_get_struct(arg, arg_val_f);
+    prec_max(prec, arg_val_f);
+    mpf_make_struct_init(res, res_val, prec);
+    mpfr_pow(res_val, self_val, arg_val_f, __gmp_default_rounding_mode);
+  } else {
+    mpf_make_struct_init(res, res_val, prec);
+
+    if (GMPZ_P(arg)) {
+      mpz_get_struct(arg, arg_val_z);
+      mpf_set_z(res_val, arg_val_z);
+      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    } else if (GMPQ_P(arg)) {
+      mpq_get_struct(arg, arg_val_q);
+      mpf_set_q(res_val, arg_val_q);
+      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    } else if (FLOAT_P(arg)) {
+      mpf_set_d(res_val, NUM2DBL(arg));
+      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    } else if (FIXNUM_P(arg)) {
+      mpfr_pow_si(res_val, self_val, FIX2INT(arg), __gmp_default_rounding_mode);
+    } else if (BIGNUM_P(arg)) {
+      mpz_temp_from_bignum(arg_val_z, arg);
+      mpf_set_z(res_val, arg_val_z);
+      mpz_temp_free(arg_val_z);
+      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
+    } else {
+      typeerror(ZQFXBD);
+    }
+
+  }
+
+  return res;
+}
+
+#endif
+
+
 /**********************************************************************
  *    _unsorted_                                                      *
  **********************************************************************/
@@ -549,8 +709,6 @@ VALUE r_gmpf_get_prec(VALUE self)
 void init_gmpf()
 {
   mGMP = rb_define_module("GMP");
-  // rb_define_module_function(mGMP, "Z", r_gmpmod_z, -1);
-  // rb_define_module_function(mGMP, "Q", r_gmpmod_q, -1);
   rb_define_module_function(mGMP, "F", r_gmpmod_f, -1);
   
   cGMP_F = rb_define_class_under (mGMP, "F", rb_cNumeric);
@@ -583,6 +741,52 @@ void init_gmpf()
   rb_define_method(cGMP_F, "<=",  r_gmpf_cmp_le, 1);
   rb_define_method(cGMP_F, "==",  r_gmpf_eq, 1);
   
+#ifdef MPFR
+  // Basic Arithmetic Functions
+  rb_define_method(cGMP_F, "sqrt", r_gmpfr_sqrt, 0);
+  
+  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);
+  
+  // Special Functions
+  rb_define_method(cGMP_F, "log",   r_gmpfr_log,   0);
+  rb_define_method(cGMP_F, "log2",  r_gmpfr_log2,  0);
+  rb_define_method(cGMP_F, "log10", r_gmpfr_log10, 0);
+  rb_define_method(cGMP_F, "exp",   r_gmpfr_exp,   0);
+  
+  rb_define_method(cGMP_F, "cos",   r_gmpfr_cos,   0);
+  rb_define_method(cGMP_F, "sin",   r_gmpfr_sin,   0);
+  rb_define_method(cGMP_F, "tan",   r_gmpfr_tan,   0);
+  rb_define_method(cGMP_F, "sec",   r_gmpfr_sec,   0);
+  rb_define_method(cGMP_F, "csc",   r_gmpfr_csc,   0);
+  rb_define_method(cGMP_F, "cot",   r_gmpfr_cot,   0);
+  
+  rb_define_method(cGMP_F, "acos",  r_gmpfr_acos,  0);
+  rb_define_method(cGMP_F, "asin",  r_gmpfr_asin,  0);
+  rb_define_method(cGMP_F, "atan",  r_gmpfr_atan,  0);
+  
+  rb_define_method(cGMP_F, "cosh",  r_gmpfr_cosh,  0);
+  rb_define_method(cGMP_F, "sinh",  r_gmpfr_sinh,  0);
+  rb_define_method(cGMP_F, "tanh",  r_gmpfr_tanh,  0);
+  
+  rb_define_method(cGMP_F, "acosh", r_gmpfr_acosh, 0);
+  rb_define_method(cGMP_F, "asinh", r_gmpfr_asinh, 0);
+  rb_define_method(cGMP_F, "atanh", r_gmpfr_atanh, 0);
+  
+  rb_define_method(cGMP_F, "log1p", r_gmpfr_log1p, 0);
+  rb_define_method(cGMP_F, "expm1", r_gmpfr_expm1, 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);
+#endif /* MPFR */
+  
   // _unsorted_
   rb_define_method(cGMP_F, "floor",  r_gmpf_floor, 0);
   rb_define_method(cGMP_F, "floor!",  r_gmpf_floor_self, 0);

data/ext/gmpf.h

@@ -9,136 +9,4 @@
 
 #include <ruby_gmp.h>
 
-#ifdef MPFR
-#define MPFR_SINGLE_FUNCTION(name)                                \
-static VALUE r_gmpfr_##name(VALUE self)                           \
-{                                                                 \
-  MP_FLOAT *self_val, *res_val;                                   \
-  unsigned long prec;                                             \
-  VALUE res;                                                      \
-                                                                  \
-  mpf_get_struct_prec(self, self_val, prec);                      \
-  mpf_make_struct_init(res, res_val, prec);                       \
-  mpfr_##name(res_val, self_val, __gmp_default_rounding_mode);    \
-                                                                  \
-  return res;                                                     \
-}
-
-MPFR_SINGLE_FUNCTION(log)
-MPFR_SINGLE_FUNCTION(exp)
-MPFR_SINGLE_FUNCTION(sqrt)
-MPFR_SINGLE_FUNCTION(cos)
-MPFR_SINGLE_FUNCTION(sin)
-MPFR_SINGLE_FUNCTION(tan)
-MPFR_SINGLE_FUNCTION(acos)
-MPFR_SINGLE_FUNCTION(asin)
-MPFR_SINGLE_FUNCTION(atan)
-MPFR_SINGLE_FUNCTION(cosh)
-MPFR_SINGLE_FUNCTION(sinh)
-MPFR_SINGLE_FUNCTION(tanh)
-MPFR_SINGLE_FUNCTION(acosh)
-MPFR_SINGLE_FUNCTION(asinh)
-MPFR_SINGLE_FUNCTION(atanh)
-MPFR_SINGLE_FUNCTION(log1p)
-MPFR_SINGLE_FUNCTION(expm1)
-MPFR_SINGLE_FUNCTION(log2)
-MPFR_SINGLE_FUNCTION(log10)
-
-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;
-  }
-}
-
-static VALUE r_gmpfr_fin_p(VALUE self)
-{
-  if (r_gmpfr_inf_p(self)) {
-    return Qfalse;
-  }
-  else {
-    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;
-  }
-}
-
-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;
-  VALUE res;
-
-  mpf_get_struct_prec(self, self_val, prec);
-
-  if (GMPF_P(arg)) {
-    mpf_get_struct(arg, arg_val_f);
-    prec_max(prec, arg_val_f);
-    mpf_make_struct_init(res, res_val, prec);
-    mpfr_pow(res_val, self_val, arg_val_f, __gmp_default_rounding_mode);
-  } else {
-    mpf_make_struct_init(res, res_val, prec);
-
-    if (GMPZ_P(arg)) {
-      mpz_get_struct(arg, arg_val_z);
-      mpf_set_z(res_val, arg_val_z);
-      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
-    } else if (GMPQ_P(arg)) {
-      mpq_get_struct(arg, arg_val_q);
-      mpf_set_q(res_val, arg_val_q);
-      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
-    } else if (FLOAT_P(arg)) {
-      mpf_set_d(res_val, FLT2DBL(arg));
-      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
-    } else if (FIXNUM_P(arg)) {
-      mpfr_pow_si(res_val, self_val, FIX2INT(arg), __gmp_default_rounding_mode);
-    } else if (BIGNUM_P(arg)) {
-      mpz_temp_from_bignum(arg_val_z, arg);
-      mpf_set_z(res_val, arg_val_z);
-      mpz_temp_free(arg_val_z);
-      mpfr_pow(res_val, self_val, res_val, __gmp_default_rounding_mode);
-    } else {
-      typeerror(ZQFXBD);
-    }
-
-  }
-
-  return res;
-}
-
-#endif
-
-
 #endif

data/ext/gmprandstate.c

@@ -205,12 +205,13 @@ VALUE r_gmprandstate_urandomb(VALUE self, VALUE arg)
 
 /*
  * call-seq:
- *   rand_state.urandomm(fixnum)
+ *   rand_state.urandomm(integer)
  *
  * From the GMP Manual:
  *
  * Generate a uniformly distributed random integer in the range 0 to
- * fixnum-1, inclusive. 
+ * _integer-1_, inclusive. _integer_ can be an instance of GMP::Z,
+ *  Fixnum, or Bignum
  */
 VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg)
 {
@@ -241,6 +242,54 @@ VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg)
   return res;
 }
 
+
+#ifdef MPFR
+/**********************************************************************
+ *    MPFR Random Numbers                                             *
+ **********************************************************************/
+
+/*
+ * call-seq:
+ *   rand_state.mpfr_urandomb()
+ *
+ * From the MPFR Manual:
+ *
+ * Generate a uniformly distributed random float in the interval 0 <= rop < 1.
+ */
+VALUE r_gmprandstate_mpfr_urandomb(int argc, VALUE *argv, VALUE self)
+{
+  MP_RANDSTATE *self_val;
+  MP_FLOAT *res_val;
+  VALUE res;
+  unsigned long prec = 0;
+  
+  if (argc > 1)
+    rb_raise (rb_eArgError, "wrong # of arguments(%d for 0 or 1)", argc);
+
+  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");
+    } 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;
+}
+#endif /* MPFR */
+
+
 void init_gmprandstate()
 {
   mGMP = rb_define_module("GMP");
@@ -258,4 +307,9 @@ void init_gmprandstate()
   // Integer Random Numbers
   rb_define_method(cGMP_RandState, "urandomb", r_gmprandstate_urandomb, 1);
   rb_define_method(cGMP_RandState, "urandomm", r_gmprandstate_urandomm, 1);
+  
+#ifdef MPFR
+  // Float Random Numbers
+  rb_define_method(cGMP_RandState, "mpfr_urandomb", r_gmprandstate_mpfr_urandomb, -1);
+#endif /* MPFR */
 }

data/ext/ruby_gmp.h

@@ -207,6 +207,40 @@ extern VALUE r_gmpf_eq(VALUE self, VALUE arg);
 extern VALUE r_gmpf_cmp(VALUE self, VALUE arg);
 extern int mpf_cmp_value(MP_FLOAT *OP, VALUE arg);
 
+// MPFR
+#ifdef MPFR
+  extern VALUE r_gmpfr_sqrt(VALUE self);
+  
+  extern VALUE r_gmpfr_log(VALUE self);
+  extern VALUE r_gmpfr_log2(VALUE self);
+  extern VALUE r_gmpfr_log10(VALUE self);
+  extern VALUE r_gmpfr_exp(VALUE self);
+  
+  extern VALUE r_gmpfr_cos(VALUE self);
+  extern VALUE r_gmpfr_sin(VALUE self);
+  extern VALUE r_gmpfr_tan(VALUE self);
+  extern VALUE r_gmpfr_sec(VALUE self);
+  extern VALUE r_gmpfr_csc(VALUE self);
+  extern VALUE r_gmpfr_cot(VALUE self);
+  
+  extern VALUE r_gmpfr_acos(VALUE self);
+  extern VALUE r_gmpfr_asin(VALUE self);
+  extern VALUE r_gmpfr_atan(VALUE self);
+  
+  extern VALUE r_gmpfr_cosh(VALUE self);
+  extern VALUE r_gmpfr_sinh(VALUE self);
+  extern VALUE r_gmpfr_tanh(VALUE self);
+  
+  extern VALUE r_gmpfr_acosh(VALUE self);
+  extern VALUE r_gmpfr_asinh(VALUE self);
+  extern VALUE r_gmpfr_atanh(VALUE self);
+  
+  extern VALUE r_gmpfrsg_const_log2();
+  extern VALUE r_gmpfrsg_const_pi();
+  extern VALUE r_gmpfrsg_const_euler();
+  extern VALUE r_gmpfrsg_const_catalan();
+#endif /* MPFR */
+
 // _unsorted_
 extern VALUE r_gmpf_sgn(VALUE self);
 extern VALUE r_gmpf_get_prec(VALUE self);
@@ -226,6 +260,11 @@ extern VALUE r_gmprandstate_seed(VALUE self, VALUE arg);
 extern VALUE r_gmprandstate_urandomb(VALUE self, VALUE arg);
 extern VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg);
 
+#ifdef MPFR
+// Float Random Numbers
+extern VALUE r_gmprandstate_mpfr_urandomb(int argc, VALUE *argv, VALUE self);
+#endif /* MPFR */
+
 
 /* from gmpbench_timing.c */
 

data/manual.tex

@@ -28,8 +28,8 @@
 \huge{gmp} &\\
 \midrule[3pt]
 \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
-\multicolumn{2}{r}{\large{Edition 0.4.1}}\\
-\multicolumn{2}{r}{\large{1 March 2010}}
+\multicolumn{2}{r}{\large{Edition 0.4.3}}\\
+\multicolumn{2}{r}{\large{8 March 2010}}
 \end{tabular}
 
 \vfill
@@ -41,7 +41,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.0.x.\\
 \\
-Copyright 2009 Sam Rawlins.\\
+Copyright 2009, 2010 Sam Rawlins.\\
 No license yet.
 \newpage
 
@@ -201,7 +201,29 @@ The gmp gem includes the namespace \texttt{GMP} and four classes within \texttt{
 
 In addition to the above four classes, there is also one constant within \texttt{GMP}:
 \begin{itemize}
-  \item \texttt{GMP::GMP\_VERSION} - The version of GMP compiled into the gmp gem.
+  \item \texttt{GMP::GMP\_VERSION} - The version of GMP linked into the gmp gem
+  \item \texttt{GMP::GMP\_CC} - The compiler that compiled GMP linked into the gmp gem
+  \item \texttt{GMP::GMP\_CFLAGS} - The compiler flags used to compile GMP linked into
+    the gmp gem
+  \item \texttt{GMP::GMP\_BITS\_PER\_LIMB} - The number of bits per limb
+\end{itemize}
+
+\section{MPFR basics}
+
+The gmp gem can optionally link to MPFR, the Multiple Precision Floating-Point Reliable
+Library. The x86-mswin32 version of the gmp gem comes with MPFR. This library uses the
+floating-point type from GMP, and thus the MPFR functions mapped in the gmp gem become
+methods in \texttt{GMP::F}.
+
+There are additional constants within \texttt{GMP} when MPFR is linked:
+\begin{itemize}
+  \item \texttt{GMP::MPFR\_VERSION} - The version of MPFR linked into the gmp gem.
+  \item \texttt{GMP::GMP\_RNDN} - Rounding mode representing "round to nearest."
+  \item \texttt{GMP::GMP\_RNDZ} - Rounding mode representing "round toward zero."
+  \item \texttt{GMP::GMP\_RNDU} - Rounding mode representing "round toward positive
+    infinity."
+  \item \texttt{GMP::GMP\_RNDD} - Rounding mode representing "round toward negative
+    infinity."
 \end{itemize}
 
 \newpage
@@ -693,8 +715,6 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 }
 \end{tabular}
 
-
-
 \subsection{Integer Logic and Bit Fiddling}
 
 \begin{tabular}{p{\methwidth} l r}
@@ -742,6 +762,35 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 }
 \end{tabular}
 
+\newpage
+\section{Rational Functions}
+
+\subsection{Initializing, Assigning Rationals}
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{new} & & GMP::Q.new $\rightarrow$ \textit{rational} \\
+& & GMP::Q.new(\textit{numerator = 0}, \textit{denominator = 1}) $\rightarrow$ \textit{rational} \\
+& & GMP::Q.new(\textit{str}) $\rightarrow$ \textit{rational} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  This method creates a new \textit{GMP::Q} rational number. It takes two optional
+  arguments for the value of the numerator and denominator. These arguments can each be
+  an instance of several classes. Here are some
+  examples:\newline
+  
+  \texttt{GMP::Q.new \qqqquad\qqqquad \#=> 0 (default) \newline
+          GMP::Q.new(1) \qqqquad\qquad\  \#=> 1 (Ruby Fixnum) \newline
+          GMP::Q.new(1,3) \qqqquad\  \#=> 1/3 (Ruby Fixnums) \newline
+          GMP::Q.new("127") \qqqquad\  \#=> 127 (Ruby String)\newline
+          GMP::Q.new(4294967296) \qquad \#=> 4294967296 (Ruby Bignum)\newline
+          GMP::Q.new(GMP::Z.new(31))  \#=> 31 (GMP Integer)}
+}
+\end{tabular}
+\newline\newline
+
+There is also a convenience method available, \texttt{GMP::Q()}.\\
+
 \newpage
 \section{Random Number Functions}
 
@@ -793,12 +842,23 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
-\textbf{urandomb} & & $state$.urandomb($n$) $\rightarrow$ $n$ \\
+\textbf{urandomb} & & $state$.urandomb($n$) $\rightarrow$ $integer$ \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Generates a uniformly distributed random integer in the range $0$ to $2^n -1$,
   inclusive.
 }
 \end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{urandomm} & & $state$.urandomm($n$) $\rightarrow$ $integer$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Generates a uniformly distributed random integer in the range $0$ to $n -1$,
+  inclusive. $n$ can be an instance of \gmpz, $Fixnum$, or $Bignum$.
+}
+\end{tabular}
 
 \end{document}

data/test/mpfr_tsqrt.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+class MPFR_TSQRT < Test::Unit::TestCase
+  def setup
+    @rand_state = GMP::RandState.new
+  end
+
+  # This really should be moved to be a method of GMP::F
+  def integer_component(f)
+    index_e = f.to_s.index('e')
+    exp = f.to_s[(index_e+1)..-1].to_i
+    return 0 if exp < 0
+    f.to_s[2..(index_e-1)][0,exp]
+  end
+  
+  def check_diverse(as, p, qs)
+    q = GMP::F(as, p)
+    q = q.sqrt
+    assert_equal(integer_component(q), qs)
+  end
+  
+  def property1(p, rounding)
+    current_rounding_mode = GMP::F.default_rounding_mode
+    GMP::F.default_rounding_mode = rounding
+    x = @rand_state.mpfr_urandomb(p)
+    y = @rand_state.mpfr_urandomb(p)
+    z = x**2 + y**2
+    z = x / z.sqrt
+    assert_between(-1, 1, z, "-1 <= x/sqrt(x^2+y^2) <= 1 should hold.")
+    GMP::F.default_rounding_mode = GMP.const_get(current_rounding_mode)
+  end
+  
+  def property2(p, rounding)
+    current_rounding_mode = GMP::F.default_rounding_mode
+    GMP::F.default_rounding_mode = rounding
+    x = @rand_state.mpfr_urandomb(p)
+    y = (x ** 2).sqrt
+    assert_true(x == y, "sqrt(x^2) = x should hold.")
+    GMP::F.default_rounding_mode = GMP.const_get(current_rounding_mode)
+  end
+  
+  def test_prec
+    (GMP::MPFR_PREC_MIN..128).each do |p|
+      property1(p, GMP::GMP_RNDN)
+      property1(p, GMP::GMP_RNDU)
+      property2(p, GMP::GMP_RNDN)
+    end
+    
+    check_diverse("635030154261163106768013773815762607450069292760790610550915652722277604820131530404842415587328",
+                  160,
+                  "796887792767063979679855997149887366668464780637")
+  end
+end

data/test/tc_f_precision.rb

@@ -2,47 +2,112 @@ require 'test_helper'
 
 class TC_precision < Test::Unit::TestCase
   def setup
+    begin
+      GMP::MPFR_VERSION
+      @initial_default_prec = GMP::F.default_prec
+    rescue
+      @initial_default_prec = GMP::F.default_prec
+    end
+  end
+  
+  def test_initial_default_precision
+    begin
+      GMP::MPFR_VERSION
+      assert_equal(53, GMP::F.default_prec, "The initial default precision with MPFR should be 53.")
+    rescue
+      assert_equal(64, GMP::F.default_prec, "The initial default precision without MPFR should be 64.")
+    end
+  end
+  
+  def test_initial_default_precision2
     @pi = GMP::F.new(3.14)
     @seven_halves = GMP::F.new(GMP::Q.new(7,2), 1000)
+    assert_in_delta(0,                      GMP::F.new(),                1e-12)
+    assert_equal(@initial_default_prec, GMP::F.new().prec)
+    assert_in_delta(3.14000000000000012434, @pi,                         1e-12)
+    assert_equal(@initial_default_prec, @pi.prec)
+    assert_in_delta(1,                      GMP::F.new(1),               1e-12)
+    assert_equal(@initial_default_prec, GMP::F.new(1).prec)
+    assert_in_delta(3.14,                   GMP::F.new("3.14"),          1e-12)
+    assert_equal(@initial_default_prec, GMP::F.new("3.14").prec)
+    assert_in_delta(4294967296,             GMP::F.new(2**32),           1e-12)
+    assert_equal(@initial_default_prec, GMP::F.new(2**32).prec)
+    assert_in_delta(3,                      GMP::F.new(GMP::Z.new(3)),   1e-12)
+    assert_equal(@initial_default_prec, GMP::F.new(GMP::Z.new(3)).prec)
+    assert_in_delta(3.5,                    GMP::F.new(GMP::Q.new(7,2)), 1e-12)
+    assert_equal(@initial_default_prec, GMP::F.new(GMP::Q.new(7,2)).prec)
+    assert_in_delta(3.14000000000000012434, GMP::F.new(@pi),             1e-12)
+    assert_equal(@initial_default_prec,        GMP::F.new(@pi).prec)
   end
   
   def test_default_precision
-    assert_equal("0.e+0", GMP::F.new().to_s)
-    assert_equal(64,      GMP::F.new().prec)
-    assert_equal("0.314000000000000012434e+1", @pi.to_s)
-    assert_equal(64,                           @pi.prec)
-    assert_equal("0.1e+1", GMP::F.new(1).to_s)
-    assert_equal(64,       GMP::F.new(1).prec)
-    assert_equal("0.314e+1", GMP::F.new("3.14").to_s)
-    assert_equal(64,         GMP::F.new("3.14").prec)
-    assert_equal("0.4294967296e+10", GMP::F.new(2**32).to_s)
-    assert_equal(64,                 GMP::F.new(2**32).prec)
-    assert_equal("0.3e+1", GMP::F.new(GMP::Z.new(3)).to_s)
-    assert_equal(64,       GMP::F.new(GMP::Z.new(3)).prec)
-    assert_equal("0.35e+1", GMP::F.new(GMP::Q.new(7,2)).to_s)
-    assert_equal(64,        GMP::F.new(GMP::Q.new(7,2)).prec)
-    assert_equal("0.314000000000000012434e+1", GMP::F.new(@pi).to_s)
-    assert_equal(64,                           GMP::F.new(@pi).prec)
+    GMP::F.default_prec = 128
+    @pi = GMP::F.new(3.14)
+    @seven_halves = GMP::F.new(GMP::Q.new(7,2), 1000)
+    assert_in_delta(0,                      GMP::F.new(),                1e-12)
+    assert_equal(128, GMP::F.new().prec)
+    assert_in_delta(3.14000000000000012434, @pi,                         1e-12)
+    assert_equal(128, @pi.prec)
+    assert_in_delta(1,                      GMP::F.new(1),               1e-12)
+    assert_equal(128, GMP::F.new(1).prec)
+    assert_in_delta(3.14,                   GMP::F.new("3.14"),          1e-12)
+    assert_equal(128, GMP::F.new("3.14").prec)
+    assert_in_delta(4294967296,             GMP::F.new(2**32),           1e-12)
+    assert_equal(128, GMP::F.new(2**32).prec)
+    assert_in_delta(3,                      GMP::F.new(GMP::Z.new(3)),   1e-12)
+    assert_equal(128, GMP::F.new(GMP::Z.new(3)).prec)
+    assert_in_delta(3.5,                    GMP::F.new(GMP::Q.new(7,2)), 1e-12)
+    assert_equal(128, GMP::F.new(GMP::Q.new(7,2)).prec)
+    assert_in_delta(3.14000000000000012434, GMP::F.new(@pi),             1e-12)
+    assert_equal(128, GMP::F.new(@pi).prec)
+    GMP::F.default_prec =  @initial_default_prec
   end
   
   def test_specific_precision
-    assert_equal("0.3140000000000000124344978758017532527446746826171875e+1", GMP::F.new(3.14, 1000).to_s)
-    assert_equal(1024,                                                        GMP::F.new(3.14, 1000).prec)
-    assert_equal("0.1e+1", GMP::F.new(1, 1000).to_s)
-    assert_equal(1024,     GMP::F.new(1, 1000).prec)
-    assert_equal("0.314e+1", GMP::F.new("3.14", 1000).to_s)
-    assert_equal(1024,       GMP::F.new("3.14", 1000).prec)
-    assert_equal("0.4294967296e+10", GMP::F.new(2**32, 1000).to_s)
-    assert_equal(1024,               GMP::F.new(2**32, 1000).prec)
-    assert_equal("0.3e+1", GMP::F.new(GMP::Z.new(3), 1000).to_s)
-    assert_equal(1024,     GMP::F.new(GMP::Z.new(3), 1000).prec)
-    assert_equal("0.35e+1", @seven_halves.to_s)
-    assert_equal(1024,      @seven_halves.prec)
-    assert_equal("0.35e+1", GMP::F.new(@seven_halves).to_s)
-    assert_equal(1024,      GMP::F.new(@seven_halves).prec)
-    assert_equal("0.3140000000000000124344978758017532527446746826171875e+1", GMP::F.new(@pi, 1000).to_s)
-    assert_equal(1024,                                                        GMP::F.new(@pi, 1000).prec)
-    assert_equal("0.35e+1", GMP::F.new(@seven_halves, 0).to_s)
-    assert_equal(64,        GMP::F.new(@seven_halves, 0).prec)
+    @pi = GMP::F.new(3.14)
+    @seven_halves = GMP::F.new(GMP::Q.new(7,2), 1024)
+    assert_equal(0, GMP::F.new(3.14, 1024).to_s =~ /0\.31400000000000001243449787580175325274467468261718750*e\+1/)
+    assert_equal(1024, GMP::F.new(3.14, 1024).prec)
+    assert_in_delta(1, GMP::F.new(1, 1024), 1e-12)
+    assert_equal(1024, GMP::F.new(1, 1024).prec)
+    assert_in_delta(3.14, GMP::F.new("3.14", 1024), 1e-12)
+    assert_equal(1024, GMP::F.new("3.14", 1024).prec)
+    assert_in_delta(4294967296, GMP::F.new(2**32, 1024), 1e-12)
+    assert_equal(1024, GMP::F.new(2**32, 1024).prec)
+    assert_in_delta(3, GMP::F.new(GMP::Z.new(3), 1024), 1e-12)
+    assert_equal(1024, GMP::F.new(GMP::Z.new(3), 1024).prec)
+    assert_in_delta(3.5, @seven_halves, 1e-12)
+    assert_equal(1024, @seven_halves.prec)
+    assert_in_delta(3.5, GMP::F.new(@seven_halves), 1e-12)
+    assert_equal(1024, GMP::F.new(@seven_halves).prec)
+    assert_equal(0, GMP::F.new(@pi, 1024).to_s =~ /0\.31400000000000001243449787580175325274467468261718750*e\+1/)
+    assert_equal(1024, GMP::F.new(@pi, 1024).prec)
+    assert_in_delta(3.5, GMP::F.new(@seven_halves, 0), 1e-12)
+    assert_equal(@initial_default_prec, GMP::F.new(@seven_halves, 0).prec)
+  end
+  
+  def test_set_default_prec
+    begin
+      GMP::MPFR_VERSION
+      GMP::F.default_prec = 100
+      assert_equal(100, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
+      GMP::F.default_prec = 130
+      assert_equal(130, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
+      GMP::F.default_prec = 1000
+      assert_equal(1000, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
+      assert_raise(RangeError) { GMP::F.default_prec = -64 }
+      assert_raise(TypeError) { GMP::F.default_prec = "Cow" }
+    rescue NameError => err
+      raise unless err.to_s == "uninitialized constant GMP::MPFR_VERSION"
+      GMP::F.default_prec = 100
+      assert_equal(128, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
+      GMP::F.default_prec = 130
+      assert_equal(160, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
+      GMP::F.default_prec = 1000
+      assert_equal(1024, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
+      assert_raise(RangeError) { GMP::F.default_prec = -64 }
+      assert_raise(TypeError) { GMP::F.default_prec = "Cow" }
+    end
+    GMP::F.default_prec =  @initial_default_prec
   end
 end

data/test/tc_mpfr_functions.rb

@@ -0,0 +1,45 @@
+require 'test_helper'
+
+class TC_MPFR_Functions < Test::Unit::TestCase
+  def setup
+    @a = GMP::F(1)
+  end
+  
+  def test_const_existence
+    assert_nothing_raised("GMP::F#const_log2 should be callable.") { GMP::F.const_log2 }
+    assert_nothing_raised("GMP::F#const_pi should be callable.") { GMP::F.const_pi }
+    assert_nothing_raised("GMP::F#const_euler should be callable.") { GMP::F.const_euler }
+    assert_nothing_raised("GMP::F#const_catalan should be callable.") { GMP::F.const_catalan }
+  end
+  
+  def test_function_existence
+    assert_nothing_raised("GMP::F.sqrt should be callable.") { @a.sqrt }
+    
+    assert_nothing_raised("GMP::F.log should be callable.") { @a.log }
+    assert_nothing_raised("GMP::F.log2 should be callable.") { @a.log2 }
+    assert_nothing_raised("GMP::F.log10 should be callable.") { @a.log10 }
+    assert_nothing_raised("GMP::F.exp should be callable.") { @a.exp }
+    
+    assert_nothing_raised("GMP::F.cos should be callable.") { @a.cos }
+    assert_nothing_raised("GMP::F.sin should be callable.") { @a.sin }
+    assert_nothing_raised("GMP::F.tan should be callable.") { @a.tan }
+    assert_nothing_raised("GMP::F.sec should be callable.") { @a.sec }
+    assert_nothing_raised("GMP::F.csc should be callable.") { @a.csc }
+    assert_nothing_raised("GMP::F.cot should be callable.") { @a.cot }
+    
+    assert_nothing_raised("GMP::F.acos should be callable.") { @a.acos }
+    assert_nothing_raised("GMP::F.asin should be callable.") { @a.asin }
+    assert_nothing_raised("GMP::F.atan should be callable.") { @a.atan }
+    
+    assert_nothing_raised("GMP::F.cosh should be callable.") { @a.cosh }
+    assert_nothing_raised("GMP::F.sinh should be callable.") { @a.sinh }
+    assert_nothing_raised("GMP::F.tanh should be callable.") { @a.tanh }
+    
+    assert_nothing_raised("GMP::F.acosh should be callable.") { @a.acosh }
+    assert_nothing_raised("GMP::F.asinh should be callable.") { @a.asinh }
+    assert_nothing_raised("GMP::F.atanh should be callable.") { @a.atanh }
+    
+    assert_nothing_raised("GMP::F.log1p should be callable.") { @a.log1p }
+    assert_nothing_raised("GMP::F.expm1 should be callable.") { @a.expm1 }
+  end
+end

data/test/tc_mpfr_random.rb

@@ -0,0 +1,49 @@
+require 'test_helper'
+
+class TC_MPFR_Random < Test::Unit::TestCase
+  def setup
+  end
+
+  def test_urandomb
+    @a = GMP::RandState.new
+    @a.seed(577)
+    g1 = [
+      GMP::F("0.39810885576093713"), GMP::F("0.97212443610368071"), GMP::F("0.23084385480845748"),
+      GMP::F("0.29428636987062717"), GMP::F("0.76895428585342840"), GMP::F("0.69329332764704654"),
+      GMP::F("0.60252711974045448"), GMP::F("0.03530920538566051"), GMP::F("0.60242124958975374"),
+    ]
+    g1.size.times do |i|
+      assert_in_delta(g1[i], @a.mpfr_urandomb, 1e-12, "GMP::RandState should mpfr_urandomb predictably.")
+    end
+  end
+  
+  def test_reseed
+    @c = GMP::RandState.new
+    @c.seed(1000)
+    assert_in_delta(GMP::F("0.78522728792921048"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+    assert_in_delta(GMP::F("0.94422653925308231"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+    assert_in_delta(GMP::F("0.60678541956109799"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+    @c.seed(1000)
+    assert_in_delta(GMP::F("0.78522728792921048"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+    assert_in_delta(GMP::F("0.94422653925308231"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+    assert_in_delta(GMP::F("0.60678541956109799"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+    @c.seed(1000)
+    assert_in_delta(GMP::F("0.78522728792921048"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+    assert_in_delta(GMP::F("0.94422653925308231"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+    assert_in_delta(GMP::F("0.60678541956109799"), @c.mpfr_urandomb, 1e-12, "GMP::RandState should re-seed correctly.")
+  end
+  
+  def test_random_independent_states
+    @d = GMP::RandState.new
+    @d.seed(577)
+    @e = GMP::RandState.new
+    @e.seed(577)
+    
+    assert_in_delta(GMP::F("0.39810885576093713"), @d.mpfr_urandomb, 1e-12, "GMP::RandState should be independent correctly.")
+    assert_in_delta(GMP::F("0.97212443610368071"), @d.mpfr_urandomb, 1e-12, "GMP::RandState should be independent correctly.")
+    assert_in_delta(GMP::F("0.39810885576093713"), @e.mpfr_urandomb, 1e-12, "GMP::RandState should be independent correctly.")
+    assert_in_delta(GMP::F("0.97212443610368071"), @e.mpfr_urandomb, 1e-12, "GMP::RandState should be independent correctly.")
+    assert_in_delta(GMP::F("0.23084385480845748"), @d.mpfr_urandomb, 1e-12, "GMP::RandState should be independent correctly.")
+    assert_in_delta(GMP::F("0.23084385480845748"), @e.mpfr_urandomb, 1e-12, "GMP::RandState should be independent correctly.")
+  end
+end

data/test/test_helper.rb

@@ -1,4 +1,5 @@
 require 'test/unit'
+require 'test_unit/assertions'  # Monkey patch
 require 'rbconfig'
 
 ENV['PATH'] = [File.expand_path(

data/test/unit_tests.rb

@@ -1,6 +1,7 @@
 #!/usr/bin/env ruby
 
 require 'test_helper'
+
 require 'tc_z'
 require 'tc_z_basic'
 require 'tc_z_logic'
@@ -23,17 +24,11 @@ require 'tc_z_jac_leg_rem'
 require 'tc_z_gcd_lcm_invert'
 require 'tc_random'
 
-class TC_default_prec < Test::Unit::TestCase
-  def test_default_prec
-    assert_equal( 64, GMP::F.default_prec, "GMP::F.default_prec should be 64.")
-    GMP::F.default_prec = 100
-    assert_equal(128, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
-    GMP::F.default_prec = 130
-    assert_equal(160, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
-    GMP::F.default_prec = 1000
-    assert_equal(1024, GMP::F.default_prec, "GMP::F.default_prec should be assignable.")
-    assert_raise(RangeError) { GMP::F.default_prec = -64 }
-    assert_raise(TypeError) { GMP::F.default_prec = "Cow" }
-    GMP::F.default_prec =  64
-  end
-end
+begin
+  GMP::MPFR_VERSION
+  require 'tc_mpfr_random'
+  require 'tc_mpfr_functions'
+  require 'mpfr_tsqrt'
+rescue
+
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: gmp
 version: !ruby/object:Gem::Version 
-  version: 0.4.1
+  version: 0.4.3
 platform: ruby
 authors: 
 - Tomasz Wegrzanowski
@@ -10,7 +10,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-03-01 00:00:00 -07:00
+date: 2010-03-08 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -37,6 +37,7 @@ files:
 - ext/ruby_gmp.h
 - ext/takeover.h
 - ext/extconf.rb
+- test/mpfr_tsqrt.rb
 - test/tc_cmp.rb
 - test/tc_division.rb
 - test/tc_fib_fac_nextprime.rb
@@ -44,6 +45,8 @@ files:
 - test/tc_f_arithmetics_coersion.rb
 - test/tc_f_precision.rb
 - test/tc_logical_roots.rb
+- test/tc_mpfr_functions.rb
+- test/tc_mpfr_random.rb
 - test/tc_q.rb
 - test/tc_q_basic.rb
 - test/tc_random.rb
@@ -90,7 +93,7 @@ post_install_message:
 rdoc_options: []
 
 require_paths: 
-- ext
+- lib
 required_ruby_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="