gmp 0.5.47 → 0.6.7

data/CHANGELOG

@@ -1,6 +1,19 @@
 0.6.7:
   * Added 9th set of Functional Mappings: GMP::Z.divisible?
   * Added 11th set of Functional Mappings: GMP::Z.congruent?
+  * Added GMP::sprintf for Ruby 1.9.x (requires Oniguruma regular expressions)
+  * Added optional parameter to GMP::F#to_s to allow a base to be passed in
+  * Finally added a rake file. My workflow now consists largely of:
+        rvm use _some_ruby_
+        rake make
+  * Added tests for GMP::F#to_s
+  * Added GMP::F#integer?
+  * Fixed tests for MPFR 3.1's PRNG
+  * Completely reorganized the benchmarks
+  * Added new performance.md, performance.html, and performance.pdf, a reworked benchmarking report
+  * Added GMP::Z#lcm, with tests
+  * Added an alloc_func, so that now GMP::Z#dup and GMP::Z#clone work
+  * Added GMP::Z#gcdext2, which only calculates g and s, for as + bt = g
 
 0.5.47:
   * Probably last release before 0.6.7

data/README.markdown

@@ -48,7 +48,7 @@ paragraph at [their homepage](http://gmplib.org/#WHAT):
 > contributors to sign paperwork where they allow us to distribute their work."
 
 Only GMP 4 or newer is supported. The following environments have been tested
-by me: gmp gem 0.5.41 on:
+by me: gmp gem 0.5.47 on:
 
 <table border="1">
   <tr>
@@ -97,20 +97,15 @@ by me: gmp gem 0.5.41 on:
         GMP 5.0.1 (3.0.0)</td>
   </tr>
   <tr>
-    <td rowspan="4">Mac OS X 10.6.4 on x86_64 (64-bit)</td>
+    <td rowspan="4">Mac OS X 10.6.8 on x86_64 (64-bit)</td>
     <td>(MRI) Ruby 1.8.7</td>
     <td>GMP 4.3.2 (2.4.2)<br />
-        GMP 5.0.1 (3.0.0)</td>
+        GMP 5.0.5 (3.1.1)</td>
   </tr>
   <tr>
-    <td>(MRI) Ruby 1.9.1</td>
-    <td>GMP 4.3.2 (2.4.2)<br />
-        GMP 5.0.1 (3.0.0)</td>
-  </tr>
-  <tr>
-    <td>(MRI) Ruby 1.9.2</td>
+    <td>(MRI) Ruby 1.9.3</td>
     <td>GMP 4.3.2 (2.4.2)<br />
-        GMP 5.0.1 (3.0.0)</td>
+        GMP 5.0.5 (3.1.1)</td>
   </tr>
   <tr>
     <td>(RBX) Rubinius 1.1.0</td>
@@ -278,7 +273,8 @@ Methods
                                certainly prime
       nextprime                next *probable* prime
       nextprime!               change the object into its next *probable* prime
-      gcd, gcdext              greatest common divisor
+      gcd, gcdext, gcdext2     greatest common divisor
+      lcm                      least common multiple
       invert(m)                invert mod m
       jacobi                   jacobi symbol
       legendre                 legendre symbol
@@ -424,7 +420,6 @@ Known Issues
 * Don't call `GMP::RandState(:lc_2exp_size)`. Give a 2nd arg.
 * Don't use multiple assignment (`a = b = GMP::Z(0)`) with functional mappings.
 * JRuby has some interesting bugs and flickering tests. GMP::Z(GMP::GMP_NUMB_MAX) for example, blows up.
-* MPFR 3.1.0 breaks some of the random tests. This is because of a known change in MPFR. I just need my tests to become aware of the change.
 
 Precision
 ---------
@@ -440,31 +435,15 @@ Precision argument, and default_precision will be rounded up to whatever GMP thi
 Benchmarking
 ------------
 
-"GMP is carefully designed to be as fast as possible." Therefore, I believe it is very important for GMP, and its various language bindings to be benchmarked. In recent years, the GMP team developed GMPbench, an elegant, weighted benchmark. Currently, they maintain a list of recent benchmark [results](http://www.gmplib.org/gmpbench.html), broken down by CPU, CPU freq, ABI, and compiler flags; GMPbench compares different processor's performance against eachother, rather than GMP against other bignum libraries, or comparing different versions of GMP.
-
-I intend to build a plug-in to GMPbench that will test the ruby gmp gem. The results of this benchmark should be directly comparable with the results of GMP (on same CPU, etc.). Rather than write a benchmark from the ground up, or try to emulate what GMPbench does, a plug-in will allow for this type of comparison. And in fact, GMPbench is (perhaps intentionally) written perfectly to allow for plugging in.
-
-Various scores are derived from GMPbench by running the `runbench` script. This script compiles and runs various individual programs that measure the performance of base functions, such as multiply, and app functions such as rsa.
-
-The gmp gem benchmark uses the GMPbench framework (that is, runbench, gexpr, and the timing methods), and plugs in ruby scripts as the individual programs. Right now, there are only four (of six) such plugged in ruby scripts:
-
-* multiply - measures performance of multiplying (or squaring) `GMP::Z` objects whose size (in bits) is given by one or two operands.
-* divide - measures performance of dividing two `GMP::Z` objects (using `tdiv`) whose size (in bits) is given by two operands.
-* gcd - measure...
-* rsa - measures performance of using RSA to sign messages. The size of `pq`, the product of the two co-prime `GMP::Z` objects, `p` and `q`, is given by one operand.
-
-**insert table here**
-
-My guess is that the increase in ruby gmp gem overhead is caused by increased efficiency in GMP; the inefficiencies of the gmp gem are relatively greater.
+Please see [performance](performance.md)
 
 Todo
 ----
 
-* `GMP::Z#to_d_2exp`, `#congruent?`, `#rootrem`, `#lcm`, `#kronecker`, `#bin`, `#fib2`, `#lucnum`, `#lucnum2`, `#hamdist`, `#combit`, `#fits_x?`
+* `GMP::Z#to_d_2exp`, `#congruent?`, `#rootrem`, `#kronecker`, `#bin`, `#fib2`, `#lucnum`, `#lucnum2`, `#hamdist`, `#combit`, `#fits_x?`
 * `GMP::Q#to_s(base)`, `GMP::F#to_s(base)` (test it!)
-* benchmark gcdext, pi
+* benchmark pi
 * a butt-load of functional mappings. 47-ish sets.
-* use Rake use Rake use Rake
 * investigate possible memory leaks when using `GMP::Q(22/7)` for example
 * beef up `r_gmpq_initialize`; I don't like to rely on `mpz_set_value`.
 * finish compile-results.rb

data/ext/gmp.c

@@ -55,6 +55,33 @@ static VALUE r_gmpfsg_set_default_prec(VALUE klass, VALUE arg)
   return Qnil;
 }
 
+VALUE r_gmpsg_sprintf2(VALUE klass, VALUE format, VALUE arg) {
+  VALUE res;
+  char *buffer;
+  char *format_str;
+  MP_INT *arg_val_z;
+  MP_RAT *arg_val_q;
+  MP_FLOAT *arg_val_f;
+  (void)klass;
+  format_str = StringValuePtr(format);
+  if (GMPZ_P(arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    gmp_asprintf(&buffer, format_str, arg_val_z);
+  } else if (GMPQ_P(arg)) {
+    mpq_get_struct (arg, arg_val_q);
+    gmp_asprintf(&buffer, format_str, arg_val_q);
+  } else if (GMPF_P(arg)) {
+    mpf_get_struct (arg, arg_val_f);
+    gmp_asprintf(&buffer, format_str, arg_val_f);
+  } else {
+    return format;
+  }
+
+  res = rb_str_new2(buffer);
+  free(buffer);
+  return res;
+}
+
 #ifdef MPFR
 mp_rnd_t r_get_rounding_mode(VALUE rnd)
 {
@@ -108,11 +135,17 @@ void Init_gmp() {
   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_VERSION_MAJOR",      INT2FIX(MPFR_VERSION_MAJOR));
+  rb_define_const(mGMP, "MPFR_VERSION_MINOR",      INT2FIX(MPFR_VERSION_MINOR));
+  rb_define_const(mGMP, "MPFR_VERSION_PATCHLEVEL", INT2FIX(MPFR_VERSION_PATCHLEVEL));
   rb_define_const(mGMP, "MPFR_PREC_MIN", INT2FIX(MPFR_PREC_MIN));
   rb_define_const(mGMP, "MPFR_PREC_MAX", INT2FIX(MPFR_PREC_MAX));
 #endif /* MPFR */
 
+  // Formatted Output Functions
+  rb_define_singleton_method(mGMP, "sprintf2", r_gmpsg_sprintf2, 2);
+
   cGMP_Z = rb_define_class_under(mGMP, "Z", rb_cInteger);
   init_gmpz ();
   rb_define_method(cGMP_Z, "coerce", r_gmpz_coerce, 1);
@@ -135,10 +168,10 @@ void Init_gmp() {
   rb_define_method (cGMP_F, "coerce", r_gmpf_coerce, 1); // new method - testing
 
 /*  rb_define_method(cGMP_F, "cmpabs",  r_gmpf_cmpabs, 1);*/
-  
+
   cGMP_RandState = rb_define_class_under (mGMP, "RandState", rb_cObject);
   init_gmprandstate ();
-  
+
   init_gmpbench_timing ();
 
   // more

data/ext/gmpbench_timing.c

@@ -10,11 +10,11 @@
     __times = 1;                                           \
     {func;}                                                \
     do {                                                   \
-	  __times <<= 1;                                       \
-	  __t0 = FIX2INT(r_gmpmod_cputime ());                 \
-	  for (__t = 0; __t < __times; __t++)                  \
-	    {func;}                                            \
-	  __tmp = FIX2INT(r_gmpmod_cputime ()) - __t0;         \
+      __times <<= 1;                                       \
+      __t0 = FIX2INT(r_gmpmod_cputime ());                 \
+      for (__t = 0; __t < __times; __t++)                  \
+        {func;}                                            \
+      __tmp = FIX2INT(r_gmpmod_cputime ()) - __t0;         \
     } while (__tmp < 250);                                 \
     (t) = (double) __tmp / __times;                        \
   } while (0)
@@ -22,7 +22,7 @@
 /* Return user CPU time measured in milliseconds.  */
 #if !defined (__sun) \
     && (defined (USG) || defined (__SVR4) || defined (_UNICOS) \
-	|| defined (__hpux) || defined (_WIN32))
+    || defined (__hpux) || defined (_WIN32))
 #include <time.h>
 
 int
@@ -55,12 +55,12 @@ r_gmpmod_cputime (VALUE self)
 VALUE
 r_gmpmod_time (VALUE self)
 {
-  (void)self;
   long int __t0, __times, __t, __tmp;
+  (void)self;
   __times = 1;
-  
+
   rb_need_block();
-  
+
   rb_yield (Qnil);
   do {
     __times <<= 1;

data/ext/gmpf.c

@@ -75,6 +75,7 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
   MP_FLOAT *self_val, *arg_val_f;
   unsigned long prec = 0;
   VALUE arg;
+  int base = 10;
 
   mpf_get_struct (self, self_val);
 
@@ -109,7 +110,6 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
     prec = mpf_get_prec (arg_val_f);
   }
 #ifdef MPFR
-  int base = 10;
   if (prec == 0)
     mpfr_init (self_val);
   else
@@ -128,7 +128,7 @@ VALUE r_gmpf_initialize(int argc, VALUE *argv, VALUE self)
       }
     }
     if (argc == 4) {
-      // FIGURE IT OUT. ACCEPT A ROUNDING MODE!
+      // TODO: FIGURE IT OUT. ACCEPT A ROUNDING MODE!
     }
 
     mpf_set_value2 (self_val, arg, base);
@@ -260,19 +260,60 @@ VALUE r_gmpf_to_d(VALUE self)
  *
  * Returns the decimal representation of _x_, as a String.
  */
-VALUE r_gmpf_to_s(VALUE self)
+VALUE r_gmpf_to_s(int argc, VALUE *argv, VALUE self)
 {
   MP_FLOAT *self_val;
   char *str, *str2;
   VALUE res;
   mp_exp_t exponent;
 
+  VALUE base;
+  int base_val = 10;
+  ID base_id;
+  const char * bin_base = "bin";                            /* binary */
+  const char * oct_base = "oct";                             /* octal */
+  const char * dec_base = "dec";                           /* decimal */
+  const char * hex_base = "hex";                       /* hexadecimal */
+  ID bin_base_id = rb_intern(bin_base);
+  ID oct_base_id = rb_intern(oct_base);
+  ID dec_base_id = rb_intern(dec_base);
+  ID hex_base_id = rb_intern(hex_base);
+
   mpf_get_struct(self, self_val);
 
+  /* TODO: accept a second optional argument, n_digits */
+  rb_scan_args (argc, argv, "01", &base);
+
+  /* The entire following stanza is determining the base. */
+  if (NIL_P (base)) { base = INT2FIX (10); }           /* default value */
+  if (FIXNUM_P (base)) {
+    base_val = FIX2INT (base);
+    if ((base_val >=   2 && base_val <= 62) ||
+        (base_val >= -36 && base_val <= -2)) {
+      /* good base */
+    } else {
+      base_val = 10;
+      rb_raise (rb_eRangeError, "base must be within [2, 62] or [-36, -2].");
+    }
+  } else if (SYMBOL_P (base)) {
+    base_id = rb_to_id (base);
+    if (base_id == bin_base_id) {
+      base_val =  2;
+    } else if (base_id == oct_base_id) {
+      base_val =  8;
+    } else if (base_id == dec_base_id) {
+      base_val = 10;
+    } else if (base_id == hex_base_id) {
+      base_val = 16;
+    } else {
+      base_val = 10;  /* TODO: should raise an exception here. */
+    }
+  }
+
   //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);
+  str = mpfr_get_str(NULL, &exponent, base_val, 0, self_val, __gmp_default_rounding_mode);
   if ((strcmp(str,  "NaN") == 0) ||
       (strcmp(str,  "Inf") == 0) ||
       (strcmp(str, "-Inf") == 0))
@@ -288,7 +329,7 @@ VALUE r_gmpf_to_s(VALUE self)
     res = rb_str_new2(str2);
     mpfr_free_str(str2);
   }
-  
+
   mpfr_free_str(str);
   return res;
 }
@@ -938,12 +979,12 @@ static VALUE r_gmpfr_##name(VALUE self)     \
 #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;                                      \
+  (void)self;                                                \
                                                              \
   rb_scan_args (argc, argv, "02", &rnd_mode, &prec);         \
                                                              \
@@ -1012,11 +1053,36 @@ MPFR_SINGLE_LONG_FUNCTION(yn)
 MPFR_SINGLE_MPF_FUNCTION(agm)
 MPFR_SINGLE_MPF_FUNCTION(hypot)
 
+//VALUE r_gmpfrsg_sprintf(int argc, VALUE *argv, VALUE self)
+  //rb_scan_args (argc, argv, "1*", &format, &list);
+VALUE r_gmpfrsg_sprintf2(VALUE klass, VALUE format, VALUE arg) {
+  VALUE res;
+  char *buffer;
+  char *format_str;
+  MP_INT *arg_val_z;
+  MP_FLOAT *arg_val_f;
+  (void)klass;
+  format_str = StringValuePtr(format);
+  if (GMPZ_P(arg)) {
+    mpz_get_struct (arg, arg_val_z);
+    mpfr_asprintf(&buffer, format_str, arg_val_z);
+  } else if (GMPF_P(arg)) {
+    mpf_get_struct (arg, arg_val_f);
+    mpfr_asprintf(&buffer, format_str, arg_val_f);
+  }
+
+  res = rb_str_new2(buffer);
+  free(buffer);
+  return res;
+}
+
 MPFR_CONST_FUNCTION(const_log2)
 MPFR_CONST_FUNCTION(const_pi)
 MPFR_CONST_FUNCTION(const_euler)
 MPFR_CONST_FUNCTION(const_catalan)
 
+MPFR_SINGLE_BOOLEAN_FUNCTION(integer_p)
+
 MPFR_SINGLE_BOOLEAN_FUNCTION(nan_p)
 MPFR_SINGLE_BOOLEAN_FUNCTION(inf_p)
 static VALUE r_gmpfr_fin_p(VALUE self)
@@ -1084,8 +1150,8 @@ static VALUE r_gmpfr_pow(VALUE self, VALUE arg)
 
 VALUE r_gmpfsg_get_default_rounding_mode(VALUE klass)
 {
-  (void)klass;
   const char *rounding_string_val;
+  (void)klass;
   rounding_string_val = mpfr_print_rnd_mode (mpfr_get_default_rounding_mode ());
   if ( rounding_string_val == NULL ) {
     return Qnil;
@@ -1097,8 +1163,8 @@ VALUE r_gmpfsg_get_default_rounding_mode(VALUE klass)
 
 VALUE r_gmpfsg_set_default_rounding_mode(VALUE klass, VALUE arg)
 {
-  (void)klass;
   VALUE mode;
+  (void)klass;
   if (GMPRND_P(arg)) {
     mode = rb_funcall (arg, rb_intern("mode"), 0);
     if (FIX2INT(mode) < 0 || FIX2INT(mode) > 3) {
@@ -1149,8 +1215,6 @@ VALUE r_gmpf_can_round(VALUE self, VALUE err, VALUE rnd1, VALUE rnd2, VALUE prec
     return Qfalse;
 }
 
-#endif
-
 
 /**********************************************************************
  *    Rounding Related Functions                                      *
@@ -1168,6 +1232,8 @@ VALUE r_gmpfsg_mpfr_buildopt_decimal_p(VALUE klass)
   return INT2FIX (mpfr_buildopt_decimal_p());
 }
 
+#endif
+
 
 /**********************************************************************
  *    _unsorted_                                                      *
@@ -1221,7 +1287,7 @@ void init_gmpf()
   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);
+  rb_define_method(cGMP_F, "to_s", r_gmpf_to_s, -1);
   rb_define_method(cGMP_F, "to_d",  r_gmpf_to_d, 0);
   rb_define_alias(cGMP_F, "to_f", "to_d");
 
@@ -1257,7 +1323,8 @@ void init_gmpf()
   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, "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);
 
 
@@ -1364,6 +1431,9 @@ void init_gmpf()
   rb_define_method(cGMP_F, "hypot", r_gmpfr_hypot,     -1);
   // "ai", r_gmpfr_ai  !! 3.0.0
 
+  // Formatted Output Functions
+  rb_define_singleton_method(cGMP_F, "sprintf2", r_gmpfrsg_sprintf2, 2);
+
   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);
@@ -1371,6 +1441,7 @@ void init_gmpf()
 
   // Integer and Remainder Related Functions
   // "integer?", r_gmpfr_integer_p
+  rb_define_method(cGMP_F, "integer?", r_gmpfr_integer_p, 0);
 
   // Rounding Related Functions
   rb_define_singleton_method (cGMP_F, "default_rounding_mode", r_gmpfsg_get_default_rounding_mode, 0);

data/ext/gmprandstate.c

@@ -47,14 +47,14 @@ VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass)
   unsigned long c_val, m2exp_val;
   unsigned long size_val;
   int free_a_val = 0;
-  
+
   ID default_algorithm      = rb_intern("default");
   ID mt_algorithm           = rb_intern("mt");
   ID lc_2exp_algorithm      = rb_intern("lc_2exp");
   ID lc_2exp_size_algorithm = rb_intern("lc_2exp_size");
-  
+
   (void)klass;
-  
+
   mprandstate_make_struct(rs, rs_val);
   rb_scan_args(argc, argv, "04", &algorithm, &arg2, &arg3, &arg4);
   if (NIL_P(algorithm))    { algorithm_id = rb_intern("default"); }  /* default value */
@@ -88,14 +88,13 @@ VALUE r_gmprandstatesg_new(int argc, VALUE *argv, VALUE klass)
     size_val = NUM2LONG(arg2);
     if (size_val > 128)
       rb_raise(rb_eArgError, "size must be within [0..128]");
-    int rv = gmp_randinit_lc_2exp_size(rs_val, size_val);
-    if (rv == 0)
+    if (gmp_randinit_lc_2exp_size (rs_val, size_val) == 0)
       rb_raise(rb_eArgError, "could not gmp_randinit_lc_2exp_size with %lu", size_val);
   }
-  
+
   if (free_a_val) { mpz_temp_free(a_val); }
   rb_obj_call_init(rs, argc, argv);
-  
+
   return rs;
 }
 
@@ -156,7 +155,7 @@ VALUE r_gmprandstate_seed(VALUE self, VALUE arg)
   MP_INT *arg_val;
 
   mprandstate_get_struct(self,self_val);
-  
+
   if (GMPZ_P(arg)) {
     mpz_get_struct(arg,arg_val);
     gmp_randseed(self_val, arg_val);
@@ -192,14 +191,14 @@ VALUE r_gmprandstate_urandomb(VALUE self, VALUE arg)
   VALUE res;
 
   mprandstate_get_struct(self,self_val);
-  
+
   if (FIXNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
     mpz_urandomb(res_val, self_val, FIX2INT(arg));
   } else {
     typeerror(X);
   }
-  
+
   return res;
 }
 
@@ -221,7 +220,7 @@ VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg)
   VALUE res;
 
   mprandstate_get_struct(self,self_val);
-  
+
   if (GMPZ_P(arg)) {
     mpz_get_struct(arg, arg_val);
   } else if (FIXNUM_P(arg)) {
@@ -234,11 +233,11 @@ VALUE r_gmprandstate_urandomm(VALUE self, VALUE arg)
   } else {
     typeerror_as(ZXB, "arg");
   }
-  
+
   mpz_make_struct_init(res, res_val);
   mpz_urandomm(res_val, self_val, arg_val);
   if (free_arg_val) { mpz_temp_free(arg_val); }
-  
+
   return res;
 }
 
@@ -260,14 +259,14 @@ VALUE r_gmprandstate_rrandomb(VALUE self, VALUE arg)
   VALUE res;
 
   mprandstate_get_struct(self,self_val);
-  
+
   if (FIXNUM_P(arg)) {
     mpz_make_struct_init(res, res_val);
     mpz_rrandomb(res_val, self_val, FIX2INT(arg));
   } else {
     typeerror(X);
   }
-  
+
   return res;
 }