gmp 0.4.1-x86-mingw32 → 0.4.3-x86-mingw32

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