gmp 0.2.2 → 0.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
data/manual.pdf CHANGED
Binary file
data/manual.tex CHANGED
@@ -19,6 +19,8 @@
19
19
  \def\qquad{\quad\quad}
20
20
  \def\qqqquad{\quad\quad\quad\quad}
21
21
  \def\cc{\colon\colon}
22
+ \def\gmpz{\textit{GMP::Z}}
23
+ \def\gmprandstate{\textit{GMP::RandState\ }}
22
24
  \frenchspacing
23
25
  \begin{document}
24
26
 
@@ -26,8 +28,8 @@
26
28
  \huge{gmp} &\\
27
29
  \midrule[3pt]
28
30
  \multicolumn{2}{r}{\large{Ruby bindings to the GMP library}}\\
29
- \multicolumn{2}{r}{\large{Edition 0.2.2}}\\
30
- \multicolumn{2}{r}{\large{21 December 2009}}
31
+ \multicolumn{2}{r}{\large{Edition 0.4.0}}\\
32
+ \multicolumn{2}{r}{\large{26 February 2010}}
31
33
  \end{tabular}
32
34
 
33
35
  \vfill
@@ -37,7 +39,7 @@
37
39
 
38
40
  \vfill
39
41
  This manual describes how to use the gmp Ruby gem, which provides bindings to
40
- the GNU multiple precision arithmetic library, version 4.3.x.\\
42
+ the GNU multiple precision arithmetic library, version 4.3.x or 5.0.x.\\
41
43
  \\
42
44
  Copyright 2009 Sam Rawlins.\\
43
45
  No license yet.
@@ -114,8 +116,7 @@ of the following versions of Ruby:
114
116
  \begin{itemize}
115
117
  \item (MRI) Ruby 1.8.6 - tested lightly.
116
118
  \item (MRI) Ruby 1.8.7 - tested seriously.
117
- \item (MRI) Ruby 1.9.1 - more of a "release candidate" state. Please report
118
- bugs.
119
+ \item (MRI) Ruby 1.9.1 - tested seriously.
119
120
  \end{itemize}
120
121
  As you can see only Matz's Ruby Interpreter (MRI) is supported. I haven't even
121
122
  put a thought into trying other interpreters/VMs. I intend to look into FFI,
@@ -126,14 +127,19 @@ Next is the platform, the combination of the architecture (processor) and OS.
126
127
  As far as I can tell, if you can compile GMP and Ruby on a given platform, you
127
128
  can use the gmp gem there too. Please report problems with that hypothesis.\\
128
129
 
129
- Lastly, GMP. GMP must be compiled and working. "and working" means you ran "make check" while installing GMP. The following versions of GMP have been tested:
130
+ Lastly, GMP. GMP must be compiled and working. "and working" means you ran "make
131
+ check" while installing GMP. The following versions of GMP have been tested:
130
132
  \begin{itemize}
131
133
  \item GMP 4.3.1
134
+ \item GMP 4.3.2
135
+ \item GMP 5.0.0
136
+ \item GMP 5.0.1
132
137
  \end{itemize}
133
138
 
134
- That's all. I don't intend to test any older versions, maybe 4.3.0 for completeness.\\
139
+ That's all. I don't intend to test any older versions, maybe 4.3.0 for
140
+ completeness.\\
135
141
 
136
- Here is a table of the exact environments I have tested the gmp gem on:\\\\
142
+ Here is a table of the exact environments on which I have tested the gmp gem:\\\\
137
143
 
138
144
  \begin{tabular}{lrr} \hline
139
145
  Platform & Ruby & GMP \\ \midrule[1pt]
@@ -141,6 +147,7 @@ Here is a table of the exact environments I have tested the gmp gem on:\\\\
141
147
  Linux (LinuxMint 7) on x86 & (MRI) Ruby 1.8.7 & GMP 4.3.1 \\ \hline
142
148
  Mac OS X 10.5.7 on x86 (32-bit) & (MRI) Ruby 1.8.6 & GMP 4.3.1 \\ \hline
143
149
  Mac OS X 10.5.7 on x86 (32-bit) & (MRI) Ruby 1.9.1 & GMP 4.3.1 \\ \hline
150
+ Windows XP on x86 (32-bit) & (MRI) Ruby 1.9.1 & GMP 5.0.1 \\ \hline
144
151
  \end{tabular}
145
152
 
146
153
  \subsection{Installing}
@@ -148,23 +155,39 @@ You may clone the gmp gem's git repository with:\\
148
155
  \\
149
156
  \texttt{git clone git://github.com/srawlins/gmp.git}\\
150
157
 
151
- Or you may install the gem from github:\\
158
+ Or you may install the gem from gemcutter:\\
159
+ \\
160
+ \texttt{gem install gmp}\\
161
+
162
+ Or you may install the gem from github (old):\\
152
163
  \\
153
164
  \texttt{gem install srawlins-gmp}\\
154
165
 
155
166
  At this time, the gem does not self-compile (how does that work?). To compile the C
156
167
  extensions, do the following:\\
157
168
  \\
158
- \texttt{cd <srawlins-gmp gem directory>/ext}\\
169
+ \texttt{cd <gmp gem directory>/ext}\\
159
170
  \texttt{ruby extconf.rb}\\
160
171
  \texttt{make}\\
161
172
 
162
173
  There shouldn't be any errors, or warnings.
163
174
 
175
+ \section{Testing the gmp gem}
176
+
177
+ Testing the gmp gem is quite simple. The test/unit\_tests.rb suite uses Unit::Test.
178
+ You can run this test suite with:\\
179
+ \\
180
+ \texttt{cd <gmp gem directory>/test}\\
181
+ \texttt{ruby unit\_tests.rb}\\
182
+
183
+ All tests should pass. If you don't have the test-unit gem installed, then you may
184
+ run into one error. I'm not sure why this is... I suspect a bug in Ruby's Test::Unit
185
+ that the test-unit gem monkey patches.
186
+
164
187
  \section{GMP and gmp gem basics}
165
188
 
166
189
  \subsection{Classes}
167
- The gmp gem includes the namespace \texttt{GMP} and three classes within \texttt{GMP}:
190
+ The gmp gem includes the namespace \texttt{GMP} and four classes within \texttt{GMP}:
168
191
  \begin{itemize}
169
192
  \item \texttt{GMP::Z} - Methods for signed integer arithmetic. There are at least 45
170
193
  methods here (still accounting).
@@ -172,9 +195,11 @@ The gmp gem includes the namespace \texttt{GMP} and three classes within \texttt
172
195
  methods here (still accounting).
173
196
  \item \texttt{GMP::F} - Methods for floating-point arithmetic. There are at least 6
174
197
  methods here (still accounting).
198
+ \item \texttt{GMP::RandState} - Methods for random number generation. There are 3
199
+ methods here.
175
200
  \end{itemize}
176
201
 
177
- In addition to the above three classes, there is also one constant within \texttt{GMP}:
202
+ In addition to the above four classes, there is also one constant within \texttt{GMP}:
178
203
  \begin{itemize}
179
204
  \item \texttt{GMP::GMP\_VERSION} - The version of GMP compiled into the gmp gem.
180
205
  \end{itemize}
@@ -415,7 +440,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
415
440
  \cmidrule(r){2-3}
416
441
  & \multicolumn{2}{p{\defnwidth}}{
417
442
  Returns the remainder after truncated division of $integer$ by $numeric$. $numeric$ can
418
- be an instance of $GMP::Z$, $Fixnum$, $Bignum$. The return object's class is always
443
+ be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
419
444
  $GMP::Z$.
420
445
  }
421
446
  \end{tabular}
@@ -427,7 +452,7 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
427
452
  \cmidrule(r){2-3}
428
453
  & \multicolumn{2}{p{\defnwidth}}{
429
454
  Returns the remainder after floored division of $integer$ by $numeric$. $numeric$ can
430
- be an instance of $GMP::Z$, $Fixnum$, $Bignum$. The return object's class is always
455
+ be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
431
456
  $GMP::Z$.
432
457
  }
433
458
  \end{tabular}
@@ -439,10 +464,21 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
439
464
  \cmidrule(r){2-3}
440
465
  & \multicolumn{2}{p{\defnwidth}}{
441
466
  Returns the remainder after ceilinged division of $integer$ by $numeric$. $numeric$ can
442
- be an instance of $GMP::Z$, $Fixnum$, $Bignum$. The return object's class is always
467
+ be an instance of $GMP::Z$, $Fixnum$, or $Bignum$. The return object's class is always
443
468
  $GMP::Z$.
444
469
  }
445
470
  \end{tabular}
471
+ \newline\newline
472
+
473
+ \begin{tabular}{p{\methwidth} l r}
474
+ \toprule
475
+ \textbf{\%} & & \textit{integer} \% \textit{numeric} $\rightarrow$ \textit{integer}\\
476
+ \cmidrule(r){2-3}
477
+ & \multicolumn{2}{p{\defnwidth}}{
478
+ Returns $integer$ modulo $numeric$. $numeric$ can be an instance of \gmpz, $Fixnum$,
479
+ or $Bignum$. The return object's class is always \gmpz.
480
+ }
481
+ \end{tabular}
446
482
 
447
483
  \subsection{Integer Roots}
448
484
 
@@ -568,6 +604,36 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
568
604
  \end{tabular}
569
605
  \newline\newline
570
606
 
607
+ \begin{tabular}{p{\methwidth} l r}
608
+ \toprule
609
+ \textbf{gcd} & & $a$.gcd($b$) $\rightarrow$ $g$ \\
610
+ \cmidrule(r){2-3}
611
+ & \multicolumn{2}{p{\defnwidth}}{
612
+ Computes the greatest common divisor of $a$ and $b$. $g$ will always be positive, even
613
+ if $a$ or $b$ is negative. $b$ can be an instance of \gmpz, $Fixnum$, or $Bignum$.
614
+ \newline\newline
615
+ \texttt{GMP::Z(24).gcd(GMP::Z(8)) \quad \#=> GMP::Z(8) \newline
616
+ GMP::Z(24).gcd(8) \quad \#=> GMP::Z(8) \newline
617
+ GMP::Z(24).gcd(2**32) \quad \#=> GMP::Z(8)}
618
+ }
619
+ \end{tabular}
620
+ \newline\newline
621
+
622
+ \begin{tabular}{p{\methwidth} l r}
623
+ \toprule
624
+ \textbf{invert} & & $a$.invert($m$) $\rightarrow$ $integer$ \\
625
+ \cmidrule(r){2-3}
626
+ & \multicolumn{2}{p{\defnwidth}}{
627
+ Computes the inverse of $a$ mod $m$. $m$ can be an instance of \gmpz, $Fixnum$, or
628
+ $Bignum$.
629
+ \newline\newline
630
+ \texttt{GMP::Z(2).invert(GMP::Z(11)) \quad \#=> GMP::Z(6) \newline
631
+ GMP::Z(3).invert(11) \quad \#=> GMP::Z(4) \newline
632
+ GMP::Z(5).invert(11) \quad \#=> GMP::Z(9)}
633
+ }
634
+ \end{tabular}
635
+ \newline\newline
636
+
571
637
  \begin{tabular}{p{\methwidth} l r}
572
638
  \toprule
573
639
  \textbf{jacobi} & & $a$.jacobi($b$) $\rightarrow$ $integer$ \\
@@ -577,10 +643,10 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
577
643
  Returns the Jacobi symbol $(a/b)$. This is defined only for $b$ odd. If $b$ is even, a
578
644
  range exception will be raised.
579
645
  \newline\newline
580
- $GMP::Z.jacobi$ (the instance method) requires $b$ to be an instance of $GMP::Z$.
646
+ \textit{GMP::Z.jacobi} (the instance method) requires $b$ to be an instance of \gmpz.
581
647
  \newline
582
- $GMP::Z\#jacobi$ (the class method) requires $a$ and $b$ each to be an instance of
583
- $GMP::Z$, $Fixnum$, or $Bignum$.
648
+ \textit{GMP::Z\#jacobi} (the class method) requires $a$ and $b$ each to be an instance of
649
+ \gmpz, $Fixnum$, or $Bignum$.
584
650
  }
585
651
  \end{tabular}
586
652
  \newline\newline
@@ -602,8 +668,136 @@ There is also a convenience method available, \texttt{GMP::Z()}.\\
602
668
  \cmidrule(r){2-3}
603
669
  & \multicolumn{2}{p{\defnwidth}}{
604
670
  Remove all occurrences of the factor $factor$ from $n$. $factor$ can be an instance of
605
- $GMP::Z$, $Fixnum$, or $Bignum$. $integer$ is the resulting integer, an instance of
606
- $GMP::Z$. $times$ is how many times $factor$ was removed, a $Fixnum$.
671
+ \gmpz, $Fixnum$, or $Bignum$. $integer$ is the resulting integer, an instance of
672
+ \gmpz. $times$ is how many times $factor$ was removed, a $Fixnum$.
673
+ }
674
+ \end{tabular}
675
+ \newline\newline
676
+
677
+ \begin{tabular}{p{\methwidth} l r}
678
+ \toprule
679
+ \textbf{fac} & & GMP::Z.fac($n$) $\rightarrow$ $integer$ \\
680
+ \cmidrule(r){2-3}
681
+ & \multicolumn{2}{p{\defnwidth}}{
682
+ Returns $n!$, or, $n$ factorial.
683
+ }
684
+ \end{tabular}
685
+ \newline\newline
686
+
687
+ \begin{tabular}{p{\methwidth} l r}
688
+ \toprule
689
+ \textbf{fib} & & GMP::Z.fib($n$) $\rightarrow$ $integer$ \\
690
+ \cmidrule(r){2-3}
691
+ & \multicolumn{2}{p{\defnwidth}}{
692
+ Returns $F[n]$, or, the $n$th Fibonacci number.
693
+ }
694
+ \end{tabular}
695
+
696
+
697
+
698
+ \subsection{Integer Logic and Bit Fiddling}
699
+
700
+ \begin{tabular}{p{\methwidth} l r}
701
+ \toprule
702
+ \textbf{and} & & $a$ \& $b$ $\rightarrow$ $integer$ \\
703
+ \cmidrule(r){2-3}
704
+ & \multicolumn{2}{p{\defnwidth}}{
705
+ Returns $integer$, the bitwise and of $a$ and $b$.
706
+ }
707
+ \end{tabular}
708
+ \newline\newline
709
+
710
+ \begin{tabular}{p{\methwidth} l r}
711
+ \toprule
712
+ \textbf{ior} & & $a$ \textbar\ $b$ $\rightarrow$ $integer$ \\
713
+ \cmidrule(r){2-3}
714
+ & \multicolumn{2}{p{\defnwidth}}{
715
+ Returns $integer$, the bitwise inclusive or of $a$ and $b$.
716
+ }
717
+ \end{tabular}
718
+ \newline\newline
719
+
720
+ \begin{tabular}{p{\methwidth} l r}
721
+ \toprule
722
+ \textbf{xor} & & $a$ \textasciicircum\ $b$ $\rightarrow$ $integer$ \\
723
+ \cmidrule(r){2-3}
724
+ & \multicolumn{2}{p{\defnwidth}}{
725
+ Returns $integer$, the bitwise exclusive or of $a$ and $b$.
726
+ }
727
+ \end{tabular}
728
+ \newline\newline
729
+
730
+ \begin{tabular}{p{\methwidth} l r}
731
+ \toprule
732
+ \textbf{scan0} & & $n$.scan0($i$) $\rightarrow$ $integer$ \\
733
+ \cmidrule(r){2-3}
734
+ & \multicolumn{2}{p{\defnwidth}}{
735
+ Scans $n$, starting from bit $i$, towards more significant bits, until the first 0 bit
736
+ is found. Return the index of the found bit.
737
+ \newline\newline
738
+ If the bit at $i$ is already what's sought, then $i$ is returned.
739
+ \newline\newline
740
+ If there's no bit found, then $INT2FIX(ULONG\_MAX)$ is returned. This will happen in
741
+ scan0 past the end of a negative number.
742
+ }
743
+ \end{tabular}
744
+
745
+ \newpage
746
+ \section{Random Number Functions}
747
+
748
+ \subsection{Random State Initialization}
749
+
750
+ \begin{tabular}{p{\methwidth} l r}
751
+ \toprule
752
+ \textbf{new} & & GMP::RandState.new $\rightarrow$ \textit{mersenne twister state} \\
753
+ & & GMP::RandState.new(:default) $\rightarrow$ \textit{mersenne twister state} \\
754
+ & & GMP::RandState(:mt) $\rightarrow$ \textit{mersenne twister random state} \\
755
+ & & GMP::RandState.new(:lc\_2exp, a, c, m2exp) $\rightarrow$ \textit{linear congruential state} \\
756
+ & & GMP::RandState.new(:lc\_2exp\_size, size) $\rightarrow$ \textit{linear congruential state} \\
757
+ \cmidrule(r){2-3}
758
+ & \multicolumn{2}{p{\defnwidth}}{
759
+ This method creates a new \gmprandstate instance. The first argument defaults
760
+ to \textit{:default} (also \textit{:mt}), which initializes the \gmprandstate for a Mersenne
761
+ Twister algorithm. No other arguments should be given if \textit{:default} or \textit{:mt} is
762
+ specified.
763
+ \newline\newline
764
+ If the first argument given is \textit{:lc\_2exp}, then the \gmprandstate is
765
+ initialized for a linear congruential algorithm. \textit{:lc\_2exp} must be followed with $a$,
766
+ $c$, and $m2exp$. The algorithm can then proceed as ($X = (a*X + c) \mod 2^{m2exp}$).
767
+ \newline\newline
768
+ \gmprandstate can also be initialized for a linear congruential algorithm with
769
+ \textit{:lc\_2exp\_size}. This initializer instead takes just one argument, $size$. $a$, $c$,
770
+ and $m2exp$ are then chosen from a table, with $m2exp/2 > size$. The maximum size
771
+ currently supported is 128.\newline
772
+
773
+ \texttt{GMP::RandState.new \newline
774
+ GMP::RandState.new(:mt) \newline
775
+ GMP::RandState.new(:lc\_2exp, 1103515245, 12345, 15) \quad \#=> Perl's old rand() \newline
776
+ GMP::RandState.new(:lc\_2exp, 25\_214\_903\_917, 11, 48) \quad \#=> drand48}
777
+ }
778
+ \end{tabular}
779
+
780
+ \subsection{Random State Seeding}
781
+
782
+ \begin{tabular}{p{\methwidth} l r}
783
+ \toprule
784
+ \textbf{seed} & & $state$.seed($integer$) $\rightarrow$ $integer$ \\
785
+ \cmidrule(r){2-3}
786
+ & \multicolumn{2}{p{\defnwidth}}{
787
+ Set an initial seed value into $state$. $integer$ can be an instance of \gmpz,
788
+ $Fixnum$, or $Bignum$.
789
+ }
790
+ \end{tabular}
791
+
792
+ \subsection{Integer Random Numbers}
793
+
794
+ \begin{tabular}{p{\methwidth} l r}
795
+ \toprule
796
+ \textbf{urandomb} & & $state$.urandomb($n$) $\rightarrow$ $n$ \\
797
+ \cmidrule(r){2-3}
798
+ & \multicolumn{2}{p{\defnwidth}}{
799
+ Generates a uniformly distributed random integer in the range $0$ to $2^n -1$,
800
+ inclusive.
607
801
  }
608
802
  \end{tabular}
609
803
 
data/test/README CHANGED
@@ -1,10 +1,3 @@
1
- TODO: Port everything to Test::Unit framework
2
- Test files 1-6 ported.
3
-
4
- Current version passes:
5
- 1-23
6
- Current version fails on these tests because:
7
- none
8
1
  Tests:
9
2
  1* initializations and to_s
10
3
  2* basic integer arithmetics and coersion to Z
@@ -24,18 +17,18 @@ Tests:
24
17
  16* floating point init with and without explicit precision
25
18
  17* basic floating point arithmetics and coersion to F
26
19
  18* default_prec and default_prec=
27
- 19 integer division methods
20
+ 19* integer division methods
28
21
  20 mpfr - exp and log
29
22
  21 mpfr - trigonometry
30
23
  22 mpfr - type tests
31
24
  23 mpfr - sqrt and power
32
- 24 jacobi, legendre, remove
25
+ 24* jacobi, legendre, remove
26
+ 25* gcd, gcdext, lcm, invert
33
27
  TODO:
34
28
  gcd, lcm
35
29
  cmpabs
36
30
  integer and integer->rational division, modulo
37
31
  more number theoretic functions
38
32
  random numbers
39
- range error exceptions
33
+ range errors
40
34
  full coverage?
41
- use more assert_in_delta
@@ -0,0 +1,109 @@
1
+ require 'test_helper'
2
+
3
+ class TC_division < Test::Unit::TestCase
4
+ def setup
5
+ @a = GMP::Z.new(5)
6
+ @b = GMP::Z.new(7)
7
+ @c = GMP::Z.new(25)
8
+ @d = GMP::Q.new(3,11)
9
+ @e = GMP::F.new(3.14)
10
+ @f = 2**32
11
+ end
12
+
13
+ def test_z_div
14
+ assert_equal(GMP::Q, (@a / @b ).class, "GMP::Z / GMP::Z should be GMP::Q.")
15
+ assert_equal(GMP::Q, (@a / 3 ).class, "GMP::Z / Fixnum should be GMP::Q.")
16
+ assert_equal(GMP::Q, (@a / 2**32).class, "GMP::Z / Bignum should be GMP::Q.")
17
+ assert_equal(GMP::Q, (@a / @c ).class, "GMP::Z / GMP::Z should be GMP::Q.")
18
+ assert_in_delta(0.7142857142, @a / @b, 1e-7, "GMP::Z./ should work.")
19
+ assert_in_delta(1.4 , @b / @a, 1e-7, "GMP::Z./ should work.")
20
+ assert_in_delta(1.6666666667, @a / 3, 1e-7, "GMP::Z./ should work.")
21
+ assert_in_delta(0.6 , 3 / @a, 1e-7, "GMP::Z./ should work.")
22
+ assert_in_delta(0.2 , @a / @c, 1e-7, "GMP::Z./ should work.")
23
+ assert_in_delta(5.0 , @c / @a, 1e-7, "GMP::Z./ should work.")
24
+ end
25
+
26
+ def test_z_tdiv
27
+ assert_equal(GMP::Z, @a.tdiv(@b).class, "GMP::Z.tdiv GMP::Z should be GMP::Z.")
28
+ assert_equal(GMP::Z, @a.tdiv(3).class, "GMP::Z.tdiv Fixnum should be GMP::Z.")
29
+ assert_equal(GMP::Z, @a.tdiv(2**32).class, "GMP::Z.tdiv Bignum should be GMP::Z.")
30
+ assert_equal(GMP::Z, @a.tdiv(@c).class, "GMP::Z.tdiv GMP::Z should be GMP::Z.")
31
+ assert_equal(0, @a.tdiv(@b), "GMP::Z.tdiv should work.")
32
+ assert_equal(1, @b.tdiv(@a), "GMP::Z.tdiv should work.")
33
+ assert_equal(1, @a.tdiv( 3), "GMP::Z.tdiv should work.")
34
+ assert_equal(0, @a.tdiv(@c), "GMP::Z.tdiv should work.")
35
+ assert_equal(5, @c.tdiv(@a), "GMP::Z.tdiv should work.")
36
+ end
37
+
38
+ def test_z_fdiv
39
+ assert_equal(GMP::Z, @a.fdiv(@b).class, "GMP::Z.fdiv GMP::Z should be GMP::Z.")
40
+ assert_equal(GMP::Z, @a.fdiv(3).class, "GMP::Z.fdiv Fixnum should be GMP::Z.")
41
+ assert_equal(GMP::Z, @a.fdiv(2**32).class, "GMP::Z.fdiv Bignum should be GMP::Z.")
42
+ assert_equal(0, @a.fdiv(@b), "GMP::Z.fdiv should work.")
43
+ assert_equal(1, @b.fdiv(@a), "GMP::Z.fdiv should work.")
44
+ assert_equal(1, @a.fdiv( 3), "GMP::Z.fdiv should work.")
45
+ assert_equal(0, @a.fdiv(@c), "GMP::Z.fdiv should work.")
46
+ assert_equal(5, @c.fdiv(@a), "GMP::Z.fdiv should work.")
47
+ end
48
+
49
+ def test_z_cdiv
50
+ assert_equal(GMP::Z, @a.cdiv(@b).class, "GMP::Z.cdiv GMP::Z should be GMP::Z.")
51
+ assert_equal(GMP::Z, @a.cdiv(3).class, "GMP::Z.cdiv Fixnum should be GMP::Z.")
52
+ assert_equal(GMP::Z, @a.cdiv(2**32).class, "GMP::Z.cdiv Bignum should be GMP::Z.")
53
+ assert_equal(1, @a.cdiv(@b), "GMP::Z.cdiv should work.")
54
+ assert_equal(2, @b.cdiv(@a), "GMP::Z.cdiv should work.")
55
+ assert_equal(2, @a.cdiv( 3), "GMP::Z.cdiv should work.")
56
+ assert_equal(1, @a.cdiv(@c), "GMP::Z.cdiv should work.")
57
+ assert_equal(5, @c.cdiv(@a), "GMP::Z.cdiv should work.")
58
+ end
59
+
60
+ def test_z_tmod
61
+ assert_equal(GMP::Z, @a.tmod(@b).class, "GMP::Z.tmod GMP::Z should be GMP::Z.")
62
+ assert_equal(GMP::Z, @a.tmod(3).class, "GMP::Z.tmod Fixnum should be GMP::Z.")
63
+ assert_equal(GMP::Z, @a.tmod(2**32).class, "GMP::Z.tmod Bignum should be GMP::Z.")
64
+ assert_equal(GMP::Z, @a.tmod(@c).class, "GMP::Z.tmod GMP::Z should be GMP::Z.")
65
+ assert_equal(5, @a.tmod(@b), "GMP::Z.tmod should work.")
66
+ assert_equal(2, @b.tmod(@a), "GMP::Z.tmod should work.")
67
+ assert_equal(2, @a.tmod( 3), "GMP::Z.tmod should work.")
68
+ assert_equal(5, @a.tmod(@c), "GMP::Z.tmod should work.")
69
+ assert_equal(0, @c.tmod(@a), "GMP::Z.tmod should work.")
70
+ end
71
+
72
+ def test_z_fmod
73
+ assert_equal(GMP::Z, @a.fmod(@b).class, "GMP::Z.fmod GMP::Z should be GMP::Z.")
74
+ assert_equal(GMP::Z, @a.fmod(3).class, "GMP::Z.fmod Fixnum should be GMP::Z.")
75
+ assert_equal(GMP::Z, @a.fmod(2**32).class, "GMP::Z.fmod Bignum should be GMP::Z.")
76
+ assert_equal(GMP::Z, @a.fmod(@c).class, "GMP::Z.fmod GMP::Z should be GMP::Z.")
77
+ assert_equal(5, @a.fmod(@b), "GMP::Z.fmod should work.")
78
+ assert_equal(2, @b.fmod(@a), "GMP::Z.fmod should work.")
79
+ assert_equal(2, @a.fmod( 3), "GMP::Z.fmod should work.")
80
+ assert_equal(5, @a.fmod(@c), "GMP::Z.fmod should work.")
81
+ assert_equal(0, @c.fmod(@a), "GMP::Z.fmod should work.")
82
+ end
83
+
84
+ def test_z_cmod
85
+ assert_equal(GMP::Z, @a.cmod(@b).class, "GMP::Z.cmod GMP::Z should be GMP::Z.")
86
+ assert_equal(GMP::Z, @a.cmod(3).class, "GMP::Z.cmod Fixnum should be GMP::Z.")
87
+ assert_equal(GMP::Z, @a.cmod(2**32).class, "GMP::Z.cmod Bignum should be GMP::Z.")
88
+ assert_equal(GMP::Z, @a.cmod(@c).class, "GMP::Z.cmod GMP::Z should be GMP::Z.")
89
+ assert_equal( -2, @a.cmod(@b), "GMP::Z.cmod should work.")
90
+ assert_equal( -3, @b.cmod(@a), "GMP::Z.cmod should work.")
91
+ assert_equal( -1, @a.cmod( 3), "GMP::Z.cmod should work.")
92
+ assert_equal(-20, @a.cmod(@c), "GMP::Z.cmod should work.")
93
+ assert_equal( 0, @c.cmod(@a), "GMP::Z.cmod should work.")
94
+ end
95
+
96
+ def test_z_mod
97
+ assert_equal(5, @a % @b, "GMP::Z should % GMP::Z correctly.")
98
+ assert_equal(2, @b % @a, "GMP::Z should % GMP::Z correctly.")
99
+ assert_equal(2, @b % 5, "GMP::Z should % Fixnum correctly.")
100
+ assert_equal(0, @b % @b, "GMP::Z should % to 0 correctly.")
101
+ assert_equal(0, @c % @a, "GMP::Z should % to 0 correctly.")
102
+ assert_equal(0, @f % @f, "GMP::Z should % Bignum correctly.")
103
+ assert_equal(0, 2*@f % @f, "GMP::Z should % Bignum correctly.")
104
+ assert_equal(5, (5*@f+5) % @f, "GMP::Z should % Bignum correctly.")
105
+ assert_raise(TypeError) { @a % 3.14 }
106
+ assert_raise(TypeError) { @a % GMP::Q(22,3) }
107
+ assert_raise(TypeError) { @a % GMP::F(3.14) }
108
+ end
109
+ end