gmp 0.5.3 → 0.5.23

data/ext/gmpz.h

@@ -9,12 +9,4 @@
 
 #include <ruby_gmp.h>
 
-#define DEFUN_INT_COND_P(fname,mpz_fname) \
-static VALUE r_gmpz_##fname(VALUE self) \
-{ \
-  MP_INT *self_val; \
-  mpz_get_struct(self, self_val); \
-  return mpz_fname(self_val)?Qtrue:Qfalse; \
-}
-
 #endif

data/ext/ruby_gmp.h

@@ -32,26 +32,23 @@
 typedef __mpfr_struct MP_FLOAT;
 #else
 typedef __mpf_struct MP_FLOAT;
+/*
+ * Here, MPFR is not included, so we are pure GMP. In GMP, mpf_get_prec returns
+ * an unsigned long int, so we will too.
+ */
+typedef unsigned long mpfr_prec_t;
 #endif /* HAVE_MPF2MPFR_H */
 
+#if __GNU_MP_VERSION < 5
+typedef unsigned long int mp_bitcnt_t;
+#endif
+
 /*
   I don't like this solution, because in gmp.h, all of these typedefs are
   marked with "gmp 1 source compatibility". :(.
 */
 typedef __gmp_randstate_struct MP_RANDSTATE;
 
-/*
- * Here, MPFR is not included, so we are pure GMP. In GMP, mpf_get_prec returns
- * an unsigned long int, so we will too.
- */
-#ifndef MPFR
-typedef unsigned long mpfr_prec_t;
-/*
- * Here, MPFR is not included, so we are pure GMP. In GMP, mpf_get_prec returns
- * an unsigned long int, so we will too.
- */
-#endif
-
 #define mpz_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_INT, c_var); }
 #define mpq_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_RAT, c_var); }
 #define mpf_get_struct(ruby_var,c_var) { Data_Get_Struct(ruby_var, MP_FLOAT, c_var); }
@@ -69,15 +66,15 @@ typedef unsigned long mpfr_prec_t;
 #define GMPQ_P(value)   (rb_obj_is_instance_of(value, cGMP_Q) == Qtrue)
 #define GMPF_P(value)   (rb_obj_is_instance_of(value, cGMP_F) == Qtrue)
 #define mpz_set_bignum(var_mpz,var_bignum) {                   \
-  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 0);  \
-  mpz_set_str (var_mpz, StringValuePtr (tmp), 0);              \
+  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32));  \
+  mpz_set_str (var_mpz, StringValuePtr (tmp), 32);              \
 }
 #define mpz_temp_alloc(var) { var=malloc(sizeof(MP_INT)); }
 #define mpz_temp_init(var) { mpz_temp_alloc(var); mpz_init(var); }
 #define mpz_temp_from_bignum(var,var_bignum) {                 \
   mpz_temp_alloc(var);                                         \
-  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 0);  \
-  mpz_init_set_str (var, StringValuePtr (tmp), 0);             \
+  VALUE tmp = rb_funcall (var_bignum, rb_intern ("to_s"), 1, INT2FIX(32));  \
+  mpz_init_set_str (var, StringValuePtr (tmp), 32);             \
 }
 #define mpz_temp_free(var) { mpz_clear(var); free(var); }
 #define mpf_temp_alloc(var) { var=malloc(sizeof(MP_FLOAT)); }
@@ -128,6 +125,7 @@ typedef unsigned long mpfr_prec_t;
 #define EXPECTED_ZX "Expected GMP::Z or Fixnum"
 #define EXPECTED_X "Expected Fixnum"
 #define EXPECTED_Z "Expected GMP::Z"
+#define EXPECTED_FD "Expected GMP::F or Float"
 #define typeerror(expected) rb_raise(rb_eTypeError, EXPECTED_##expected)
 #define typeerror_as(expected, argname) rb_raise(rb_eTypeError, EXPECTED_##expected " as " argname)
 
@@ -226,10 +224,6 @@ extern VALUE r_gmpq_add(VALUE self, VALUE arg);
 extern VALUE r_gmpq_sub(VALUE self, VALUE arg);
 extern VALUE r_gmpq_mul(VALUE self, VALUE arg);
 extern VALUE r_gmpq_div(VALUE self, VALUE arg);
-extern VALUE r_gmpq_neg(VALUE self);
-extern VALUE r_gmpq_neg_self(VALUE self);
-extern VALUE r_gmpq_abs(VALUE self);
-extern VALUE r_gmpq_abs_self(VALUE self);
 extern VALUE r_gmpq_inv(VALUE self);
 extern VALUE r_gmpq_inv_self(VALUE self);
 

data/manual.tex

@@ -34,8 +34,8 @@
 \huge{gmp} &\\
 \midrule[3pt]
 \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
-\multicolumn{2}{r}{\large{Edition 0.5.3}}\\
-\multicolumn{2}{r}{\large{20 September 2010}}
+\multicolumn{2}{r}{\large{Edition 0.5.23}}\\
+\multicolumn{2}{r}{\large{04 October 2010}}
 \end{tabular}
 
 \vfill
@@ -146,11 +146,10 @@ of the following versions of Ruby:
   \item (MRI) Ruby 1.8.7 - tested seriously.
   \item (MRI) Ruby 1.9.1 - tested seriously.
   \item (MRI) Ruby 1.9.2 - tested seriously.
+  \item (REE) Ruby 1.8.7 - tested lightly.
 \end{itemize}
-As you can see only Matz's Ruby Interpreter (MRI) is supported. I haven't even
-put a thought into trying other interpreters/VMs. I intend to look into FFI,
-which supposedly will allow me to load this extension into JRuby and Rubinius,
-not sure about others...\\
+As you can see only Matz's Ruby Interpreter (MRI) is supported. I've just started to poke
+around with REE. Everything seems to work on REE 1.8.7 on Linux, x86 and x86\_64.\\
 
 Next is the platform, the combination of the architecture (processor) and OS.
 As far as I can tell, if you can compile GMP and Ruby (and optionally MPFR) on
@@ -194,6 +193,12 @@ the given version of MPFR:\\\\
                                            & (MRI) Ruby 1.9.1 & GMP 5.0.1 & (3.0.0) \\
                                            & (MRI) Ruby 1.9.2 & GMP 4.3.2 & (2.4.2) \\
                                            & (MRI) Ruby 1.9.2 & GMP 5.0.1 & (3.0.0) \\ \hline
+  Windows 7 on x86\_64 (64-bit)            & (MRI) Ruby 1.8.7 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.8.7 & GMP 5.0.1 & (3.0.0) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.1 & GMP 5.0.1 & (3.0.0) \\
+                                           & (MRI) Ruby 1.9.2 & GMP 4.3.2 & (2.4.2) \\
+                                           & (MRI) Ruby 1.9.2 & GMP 5.0.1 & (3.0.0) \\ \hline
   Windows XP on x86 (32-bit)               & (MRI) Ruby 1.9.1 & GMP 4.3.2 & (2.4.2) \\
                                            & (MRI) Ruby 1.9.1 & GMP 5.0.1 & (3.0.0) \\ \hline
 \end{tabular}\\\\
@@ -266,6 +271,8 @@ In addition to the above four classes, there are also four constants within \tex
   \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
+  \item \texttt{GMP::GMP\_NUMB\_MAX} - The maximum value that can be stored in the number
+    part of a limb.
 \end{itemize}
 
 \section{MPFR basics}
@@ -278,6 +285,8 @@ 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::MPFR\_PREC\_MIN} - The minimum precision available.
+  \item \texttt{GMP::MPFR\_PREC\_MAX} - The maximum precision available
   \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
@@ -458,12 +467,24 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
-\textbf{addmul!} & & \textit{integer}.addmul!(\textit{a}, \textit{b}) $\rightarrow$ \textit{numeric} \\
+\textbf{addmul!} & & \textit{integer}.addmul!(\textit{b}, \textit{c}) $\rightarrow$ \textit{numeric} \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
-  Sets \textit{integer} to the sum of \textit{integer} and the product of \textit{a} and
-  \textit{b}. This destructive method calculates the result in place. Both \textit{a} and
-  \textit{b} can be an instance of \gmpz, \textit{Fixnum}, or \textit{Bignum}.
+  Sets \textit{integer} to the sum of \textit{integer} and the product of \textit{b} and
+  \textit{c}. This destructive method calculates the result in place. Both \textit{b} and
+  \textit{c} can be an instance of \gmpz, \textit{Fixnum}, or \textit{Bignum}.
+}
+\end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{submul!} & & \textit{integer}.submul!(\textit{b}, \textit{c}) $\rightarrow$ \textit{numeric} \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Sets \textit{integer} to the difference of \textit{integer} and the product of \textit{b} and
+  \textit{c}. This destructive method calculates the result in place. Both \textit{b} and
+  \textit{c} can be an instance of \gmpz, \textit{Fixnum}, or \textit{Bignum}.
 }
 \end{tabular}
 \newline\newline
@@ -583,6 +604,17 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
   or $Bignum$. The return object's class is always \gmpz.
 }
 \end{tabular}
+\newline\newline
+
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{divisible?} & & \textit{integer}.divisible? \textit{numeric} $\rightarrow$ \textit{boolean}\\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Returns whether $integer$ is divisible by $numeric$. $numeric$ can be an instance of \gmpz, $Fixnum$,
+  or $Bignum$.
+}
+\end{tabular}
 
 \newpage
 \subsection{Integer Exponentiation}
@@ -675,7 +707,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 
 \begin{tabular}{p{\methwidth} l r}
 \toprule
-\textbf{is\_probab\_prime?} & & $integer$.is\_probab\_prime?($reps = 5$) $\rightarrow$ 0, 1, or 2 \\
+\textbf{probab\_prime?} & & $integer$.probab\_prime?($reps = 5$) $\rightarrow$ 0, 1, or 2 \\
 \cmidrule(r){2-3}
 & \multicolumn{2}{p{\defnwidth}}{
   Determine whether $integer$ is prime. Returns 2 if $integer$ is definitely prime,
@@ -726,6 +758,19 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
 \end{tabular}
 \newline\newline
 
+\begin{tabular}{p{\methwidth} l r}
+\toprule
+\textbf{gcdext} & & $a$.gcd($b$) $\rightarrow$ $g$, $s$, $t$ \\
+\cmidrule(r){2-3}
+& \multicolumn{2}{p{\defnwidth}}{
+  Computes the greatest common divisor of $a$ and $b$, in addition to $s$ and $t$, the
+  coefficients satisfying $a*s + b*t = g$. $g$ will always be positive, even if $a$ or
+  $b$ is negative. $s$ and $t$ are chosen such that $|s| <= |b|$ and $|t| <= |a|$. $b$
+  can be an instance of \gmpz, $Fixnum$, or $Bignum$.
+}
+\end{tabular}
+\newline\newline
+
 \begin{tabular}{p{\methwidth} l r}
 \toprule
 \textbf{invert} & & $a$.invert($m$) $\rightarrow$ $integer$ \\

data/test/gmp_tgcd.rb

@@ -0,0 +1,126 @@
+require './test_helper'
+
+class GMP_TGCD < Test::Unit::TestCase
+  def setup
+    @rand_state = GMP::RandState.new
+    @min_operand_bitsize = 1
+  end
+  
+  def one_test(op1, op2, ref, i)
+    g1, s, t = op1.gcdext(op2)
+    
+    if ref# and ref != g1
+      assert_true(ref == g1, "GMP::Z#gcdext should work...")
+    end
+    
+    gcdext_valid_p(op1, op2, g1, s)
+    
+    g2 = op1.gcd(op2)
+    assert_equal(g1, g2, "gcd and gcdext should produce the same gcd.")
+    
+    g2, temp1, temp2 = op1.gcdext(op2)
+    temp1 *= op1
+    temp2 *= op2
+    temp1 += temp2
+    assert_true(g1 == g2 || g2 == temp1, "gcdext should work...")
+  end
+  
+  def gcdext_valid_p(a, b, g, s)
+    assert_true(g >= 0, "When [g, s, t] = a.gcdext(b), g must > 0 (g=#{g}, s=#{s}, a=#{a}, b=#{b})")
+    
+    if a.sgn == 0
+      assert_true(g.cmpabs(b) == 0, "When [g, s, t] = a.gcdext(b), if a == 0, g must == |b|")
+      assert_true(s == 0, "When [g, s, t] = a.gcdext(b), if a == 0, s should == 0")
+      return
+    end
+    
+    if b.sgn == 0
+      assert_true(g.cmpabs(a) == 0, "When [g, s, t] = a.gcdext(b), if b == 0, g must == |a|")
+      assert_true(s == a.sgn, "When [g, s, t] = a.gcdext(b), if a == 0, s should == a.sgn")
+      return
+    end
+    
+    assert_false(g.sgn <= 0, "When [g, s, t] = a.gcdext(b), if neither a == 0 nor b == 0, g must > 0")
+    
+    temp1 = a.tdiv(g)
+    temp3 = a.tmod(g)
+    assert_true(temp3.sgn == 0, "When [g, s, t] = a.gcdext(b), g must divide a.")
+    temp2 = b.tdiv(g)
+    temp3 = b.tmod(g)
+    assert_true(temp3.sgn == 0, "When [g, s, t] = a.gcdext(b), g must divide b.")
+    
+    if GMP::GMP_VERSION > "4.3.1"
+    assert_true(s.cmpabs(GMP::Z(1)) == 0 || (s*2).abs.cmpabs(temp2) <= 0, "GMP::Z#gcdext should work: #{s}.cmpabs(1)==0 or (#{s*2}.abs.cmpabs(#{temp2})<=0")
+    end
+    
+    temp2 = s * a
+    temp2 = g - temp2
+    temp3 = temp2.tmod(b)
+    temp2 = temp2.tdiv(b)
+    assert_true(temp3.sgn == 0, "When [g, s, t] = a.gcdext(b), g must divide a.")
+    
+    if GMP::GMP_VERSION > "4.3.1"
+    assert_true(temp2.cmpabs(GMP::Z(1)) == 0 || (temp2*2).abs.cmpabs(temp1) <= 0, "GMP::Z#gcdext should work...")
+    end
+  end
+
+  def test_gcdext
+    reps = 200
+    #check_data
+    
+    op2 = GMP::Z(GMP::GMP_NUMB_MAX)
+    op1 = op2 << 100
+    op1 += op2
+    op2 *= 2
+    one_test(op1, op2, nil, -1)
+    
+    (0...reps).each do |i|
+      bs = @rand_state.urandomb(32)
+      size_range = bs.to_i % 17 + 2
+      bs = @rand_state.urandomb(size_range)
+      op1 = @rand_state.urandomb(bs.to_i + @min_operand_bitsize)
+      bs = @rand_state.urandomb(size_range)
+      op2 = @rand_state.urandomb(bs.to_i + @min_operand_bitsize)
+      
+      bs = @rand_state.urandomb(8)
+      bsi = bs.to_i
+      
+      if bsi & 0x3c == 4
+        op1 *= op2
+      elsif bsi & 0x3c == 8
+        op2 *= op1
+      end
+      
+      op1.neg! if bsi & 1 != 0
+      op2.neg! if bsi & 2 != 0
+      
+      one_test(op1, op2, nil, i)
+      
+      op1 = GMP::Z(0)
+      bs = @rand_state.urandomb(32)
+      bs = @rand_state.urandomb(bs.to_i % 16 + 1)
+      op2 = @rand_state.rrandomb(bs.to_i)
+      op2 += 1
+      ref = op2
+      
+      # UNTIL I CAN ACCESS GCD_DC_THRESHOLD
+      chain_len = 10
+      (1..chain_len).each do |j|
+        bs = @rand_state.urandomb(32)
+	    bs = @rand_state.urandomb(bs.to_i % 12 + 1)
+	    temp2 = @rand_state.rrandomb(bs.to_i + 1)
+        temp2 += 1
+	    temp1 = op2 * temp2
+        op1 += temp1
+
+        bs = @rand_state.urandomb(32)
+	    bs = @rand_state.urandomb(bs.to_i % 12 + 1)
+	    temp2 = @rand_state.rrandomb(bs.to_i + 1)
+        temp2 += 1
+        temp1 = op1 * temp2
+        op2 += temp1
+      end
+      one_test(op1, op2, ref, i)
+    end
+  end
+end

data/test/mpfr_tconst_euler.rb

@@ -0,0 +1,36 @@
+require './test_helper'
+
+class MPFR_TCONST_EULER < Test::Unit::TestCase
+  def setup
+    @rand_state = GMP::RandState.new
+    
+    if GMP::MPFR_VERSION >= "3.0.0"
+      @mpfr_rnd_max = 5
+    else
+      @mpfr_rnd_max = 4
+    end
+  end
+
+  def test_const_euler
+    prec = 53
+
+    y = GMP::F.const_euler(GMP::GMP_RNDN, 32)
+    z = GMP::F("0.10010011110001000110011111100011", 32, 2)
+    assert_equal(z, y, "Const Euler to precision 32 should be accurate.")
+
+    (2..200).each do |p|
+      z.prec= p
+      t = GMP::F(0, p)
+      yprec = p+10
+
+      (0...@mpfr_rnd_max).each do |rnd|
+        y.prec = yprec
+        GMP::F.const_euler(y, rnd)
+        err = rnd == GMP::GMP_RNDN ? yprec+1 : yprec
+        if y.can_round?(err, rnd, rnd, p)
+        
+        end
+      end
+    end
+  end
+end

data/test/tc_mpfr_functions.rb

@@ -1,13 +1,32 @@
 class TC_MPFR_Functions < Test::Unit::TestCase
   def setup
     @a = GMP::F(1)
+    @b = GMP::F(2)
   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 }
+    constants = ["const_log2", "const_pi", "const_euler", "const_catalan"]
+
+    constants.each do |c|
+      assert_nothing_raised("GMP::F##{c} can be called.") {
+        GMP::F.send(c)
+      }
+      assert_nothing_raised("GMP::F##{c} can be called w/ 1 arg: rounding_mode.") {
+        GMP::F.send(c, GMP::GMP_RNDN)
+      }
+      assert_nothing_raised("GMP::F##{c} can be called w/ 1 arg: rounding_mode.") {
+        GMP::F.send(c, GMP::GMP_RNDZ)
+      }
+      assert_nothing_raised("GMP::F##{c} can be called w/ 2 args: rounding_mode, prec.") {
+        GMP::F.send(c, GMP::GMP_RNDN, 32)
+      }
+      assert_nothing_raised("GMP::F##{c} can be called w/ 2 args: rounding_mode, prec.") {
+        GMP::F.send(c, GMP::GMP_RNDN, 128)
+      }
+      assert_nothing_raised("GMP::F##{c} can be called w/ 2 args: rounding_mode, prec.") {
+        GMP::F.send(c, GMP::GMP_RNDN, 200)
+      }
+    end
   end
   
   def test_function_existence
@@ -32,18 +51,19 @@ class TC_MPFR_Functions < Test::Unit::TestCase
     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.sin_cos should be callable.") { @a.sin_cos }
     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.atan2 should be callable.") { @a.atan2(@b) }
     
     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.sinh_cosh should be callable.") { @a.sinh_cosh }
     assert_nothing_raised("GMP::F.sech should be callable.") { @a.sech }
     assert_nothing_raised("GMP::F.csch should be callable.") { @a.csch }
     assert_nothing_raised("GMP::F.coth should be callable.") { @a.coth }
@@ -76,26 +96,37 @@ class TC_MPFR_Functions < Test::Unit::TestCase
     assert_nothing_raised("GMP::F.yn should be callable.") { @a.yn(0) }
     assert_nothing_raised("GMP::F.yn should be callable.") { @a.yn(1) }
     assert_nothing_raised("GMP::F.yn should be callable.") { @a.yn(2) }
+    
+    assert_nothing_raised("GMP::F.agm should be callable.") { @a.agm(@b) }
+    assert_nothing_raised("GMP::F.hypot should be callable.") { @a.hypot(@b) }
   end
   
   def test_function_parameters
-    functions = [:sqrt, :rec_sqrt, :cbrt,
-                 :log, :log2, :log10, :exp, :exp2, :exp10,
-                 :cos, :sin, :tan, :sec, :csc, :cot, :acos, :asin, :atan,
-                 :cosh, :sinh, :tanh, :sech, :csch, :coth,
-                 :acosh, :asinh, :atanh,
-                 :log1p, :expm1, :eint, :li2, :gamma, :lngamma,
-                 :zeta, :erf, :erfc,
-                 :j0, :j1, :y0, :y1
-                ]
-    functions += [:digamma] if GMP::MPFR_VERSION >= "3.0.0"
+    single_functions = [:sqrt, :rec_sqrt, :cbrt,
+                        :log, :log2, :log10, :exp, :exp2, :exp10,
+                        :cos, :sin, :tan, :sin_cos, :sec, :csc, :cot,
+                        :acos, :asin, :atan,
+                        :cosh, :sinh, :tanh, :sech, :csch, :coth,
+                        :acosh, :asinh, :atanh,
+                        :log1p, :expm1, :eint, :li2, :gamma, :lngamma,
+                        :zeta, :erf, :erfc,
+                        :j0, :j1, :y0, :y1
+                       ]
+    single_functions += [:digamma] if GMP::MPFR_VERSION >= "3.0.0"
+    double_functions = [:sin_cos, :sinh_cosh]
+    single_mpf_functions = [:atan2, :agm, :hypot]
     
-    functions.each do |f|
+    (single_functions + double_functions).each do |f|
       assert_nothing_raised("GMP::F.#{f} can be called w/ 1 arg: rounding_mode.") { @a.send(f, GMP::GMP_RNDN) }
       assert_nothing_raised("GMP::F.#{f} can be called w/ 1 arg: rounding_mode.") { @a.send(f, GMP::GMP_RNDZ) }
       assert_nothing_raised("GMP::F.#{f} can be called w/ 2 args: rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 32) }
       assert_nothing_raised("GMP::F.#{f} can be called w/ 2 args: rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 128) }
       assert_nothing_raised("GMP::F.#{f} can be called w/ 2 args: rounding_mode, prec.") { @a.send(f, GMP::GMP_RNDN, 200) }
     end
+    double_functions.each do |f|
+      assert_nothing_raised("GMP::F.#{f} can be called w/ 3 args: rounding_mode, prec, prec.") { @a.send(f, GMP::GMP_RNDN,  64,  64) }
+      assert_nothing_raised("GMP::F.#{f} can be called w/ 3 args: rounding_mode, prec, prec.") { @a.send(f, GMP::GMP_RNDN, 128,  64) }
+      assert_nothing_raised("GMP::F.#{f} can be called w/ 3 args: rounding_mode, prec, prec.") { @a.send(f, GMP::GMP_RNDN,  64, 128) }
+    end
   end
 end