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

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