1 /* Test mp*_class functions.
2
3 Copyright 2002, 2003 Free Software Foundation, Inc.
4
5 This file is part of the GNU MP Library test suite.
6
7 The GNU MP Library test suite is free software; you can redistribute it
8 and/or modify it under the terms of the GNU General Public License as
9 published by the Free Software Foundation; either version 3 of the License,
10 or (at your option) any later version.
11
12 The GNU MP Library test suite is distributed in the hope that it will be
13 useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
15 Public License for more details.
16
17 You should have received a copy of the GNU General Public License along with
18 the GNU MP Library test suite. If not, see https://www.gnu.org/licenses/. */
19
20
21 /* Note that we don't use <climits> for LONG_MIN, but instead our own
22 definitions in gmp-impl.h. In g++ 2.95.4 (debian 3.0) under
23 -mcpu=ultrasparc, limits.h sees __sparc_v9__ defined and assumes that
24 means long is 64-bit long, but it's only 32-bits, causing fatal compile
25 errors. */
26
27 #include "config.h"
28
29 #include <string>
30
31 #include "gmpxx.h"
32 #include "gmp-impl.h"
33 #include "tests.h"
34
35 using namespace std;
36
37
38 void
check_mpz(void)39 check_mpz (void)
40 {
41 // mpz_class::fits_sint_p
42 {
43 bool fits;
44 mpz_class z;
45 z = INT_MIN; fits = z.fits_sint_p(); ASSERT_ALWAYS (fits);
46 z--; fits = z.fits_sint_p(); ASSERT_ALWAYS (! fits);
47 z = INT_MAX; fits = z.fits_sint_p(); ASSERT_ALWAYS (fits);
48 z++; fits = z.fits_sint_p(); ASSERT_ALWAYS (! fits);
49 }
50
51 // mpz_class::fits_uint_p
52 {
53 bool fits;
54 mpz_class z;
55 z = 0; fits = z.fits_uint_p(); ASSERT_ALWAYS (fits);
56 z--; fits = z.fits_uint_p(); ASSERT_ALWAYS (! fits);
57 z = UINT_MAX; fits = z.fits_uint_p(); ASSERT_ALWAYS (fits);
58 z++; fits = z.fits_uint_p(); ASSERT_ALWAYS (! fits);
59 }
60
61 // mpz_class::fits_slong_p
62 {
63 bool fits;
64 mpz_class z;
65 z = LONG_MIN; fits = z.fits_slong_p(); ASSERT_ALWAYS (fits);
66 z--; fits = z.fits_slong_p(); ASSERT_ALWAYS (! fits);
67 z = LONG_MAX; fits = z.fits_slong_p(); ASSERT_ALWAYS (fits);
68 z++; fits = z.fits_slong_p(); ASSERT_ALWAYS (! fits);
69 }
70
71 // mpz_class::fits_ulong_p
72 {
73 bool fits;
74 mpz_class z;
75 z = 0; fits = z.fits_ulong_p(); ASSERT_ALWAYS (fits);
76 z--; fits = z.fits_ulong_p(); ASSERT_ALWAYS (! fits);
77 z = ULONG_MAX; fits = z.fits_ulong_p(); ASSERT_ALWAYS (fits);
78 z++; fits = z.fits_ulong_p(); ASSERT_ALWAYS (! fits);
79 }
80
81 // mpz_class::fits_sshort_p
82 {
83 bool fits;
84 mpz_class z;
85 z = SHRT_MIN; fits = z.fits_sshort_p(); ASSERT_ALWAYS (fits);
86 z--; fits = z.fits_sshort_p(); ASSERT_ALWAYS (! fits);
87 z = SHRT_MAX; fits = z.fits_sshort_p(); ASSERT_ALWAYS (fits);
88 z++; fits = z.fits_sshort_p(); ASSERT_ALWAYS (! fits);
89 }
90
91 // mpz_class::fits_ushort_p
92 {
93 bool fits;
94 mpz_class z;
95 z = 0; fits = z.fits_ushort_p(); ASSERT_ALWAYS (fits);
96 z--; fits = z.fits_ushort_p(); ASSERT_ALWAYS (! fits);
97 z = USHRT_MAX; fits = z.fits_ushort_p(); ASSERT_ALWAYS (fits);
98 z++; fits = z.fits_ushort_p(); ASSERT_ALWAYS (! fits);
99 }
100
101 // mpz_class::get_mpz_t
102 {
103 mpz_class z(0);
104 mpz_ptr p = z.get_mpz_t();
105 ASSERT_ALWAYS (mpz_cmp_ui (p, 0) == 0);
106 }
107 {
108 mpz_class z(0);
109 mpz_srcptr p = z.get_mpz_t();
110 ASSERT_ALWAYS (mpz_cmp_ui (p, 0) == 0);
111 }
112
113 // mpz_class::get_d
114 // mpz_class::get_si
115 // mpz_class::get_ui
116 {
117 mpz_class z(123);
118 { double d = z.get_d(); ASSERT_ALWAYS (d == 123.0); }
119 { long l = z.get_si(); ASSERT_ALWAYS (l == 123L); }
120 { long u = z.get_ui(); ASSERT_ALWAYS (u == 123L); }
121 }
122 {
123 mpz_class z(-123);
124 { double d = z.get_d(); ASSERT_ALWAYS (d == -123.0); }
125 { long l = z.get_si(); ASSERT_ALWAYS (l == -123L); }
126 }
127
128 // mpz_class::get_str
129 {
130 mpz_class z(123);
131 string s;
132 s = z.get_str(); ASSERT_ALWAYS (s == "123");
133 s = z.get_str(16); ASSERT_ALWAYS (s == "7b");
134 s = z.get_str(-16); ASSERT_ALWAYS (s == "7B");
135 }
136
137 // mpz_class::set_str
138 {
139 mpz_class z;
140 int ret;
141 ret = z.set_str ("123", 10); ASSERT_ALWAYS (ret == 0 && z == 123);
142 ret = z.set_str ("7b", 16); ASSERT_ALWAYS (ret == 0 && z == 123);
143 ret = z.set_str ("7B", 16); ASSERT_ALWAYS (ret == 0 && z == 123);
144 ret = z.set_str ("0x7B", 0); ASSERT_ALWAYS (ret == 0 && z == 123);
145
146 ret = z.set_str (string("123"), 10); ASSERT_ALWAYS (ret == 0 && z == 123);
147 ret = z.set_str (string("7b"), 16); ASSERT_ALWAYS (ret == 0 && z == 123);
148 ret = z.set_str (string("7B"), 16); ASSERT_ALWAYS (ret == 0 && z == 123);
149 ret = z.set_str (string("0x7B"), 0); ASSERT_ALWAYS (ret == 0 && z == 123);
150 }
151 }
152
153 void
check_mpq(void)154 check_mpq (void)
155 {
156 // mpq_class::canonicalize
157 {
158 mpq_class q(12,9);
159 q.canonicalize();
160 ASSERT_ALWAYS (q.get_num() == 4);
161 ASSERT_ALWAYS (q.get_den() == 3);
162 }
163
164 // mpq_class::get_d
165 {
166 mpq_class q(123);
167 { double d = q.get_d(); ASSERT_ALWAYS (d == 123.0); }
168 }
169 {
170 mpq_class q(-123);
171 { double d = q.get_d(); ASSERT_ALWAYS (d == -123.0); }
172 }
173
174 // mpq_class::get_mpq_t
175 {
176 mpq_class q(0);
177 mpq_ptr p = q.get_mpq_t();
178 ASSERT_ALWAYS (mpq_cmp_ui (p, 0, 1) == 0);
179 }
180 {
181 mpq_class q(0);
182 mpq_srcptr p = q.get_mpq_t();
183 ASSERT_ALWAYS (mpq_cmp_ui (p, 0, 1) == 0);
184 }
185
186 // mpq_class::get_num, mpq_class::get_den
187 {
188 const mpq_class q(4,5);
189 mpz_class z;
190 z = q.get_num(); ASSERT_ALWAYS (z == 4);
191 z = q.get_den(); ASSERT_ALWAYS (z == 5);
192 }
193
194 // mpq_class::get_num_mpz_t, mpq_class::get_den_mpz_t
195 {
196 mpq_class q(4,5);
197 mpz_ptr p;
198 p = q.get_num_mpz_t(); ASSERT_ALWAYS (mpz_cmp_ui (p, 4) == 0);
199 p = q.get_den_mpz_t(); ASSERT_ALWAYS (mpz_cmp_ui (p, 5) == 0);
200 }
201 {
202 const mpq_class q(4,5);
203 mpz_srcptr p;
204 p = q.get_num_mpz_t(); ASSERT_ALWAYS (mpz_cmp_ui (p, 4) == 0);
205 p = q.get_den_mpz_t(); ASSERT_ALWAYS (mpz_cmp_ui (p, 5) == 0);
206 }
207
208 // mpq_class::get_str
209 {
210 mpq_class q(17,11);
211 string s;
212 s = q.get_str(); ASSERT_ALWAYS (s == "17/11");
213 s = q.get_str(10); ASSERT_ALWAYS (s == "17/11");
214 s = q.get_str(16); ASSERT_ALWAYS (s == "11/b");
215 s = q.get_str(-16); ASSERT_ALWAYS (s == "11/B");
216 }
217
218 // mpq_class::set_str
219 {
220 mpq_class q;
221 int ret;
222 ret = q.set_str ("123", 10); ASSERT_ALWAYS (ret == 0 && q == 123);
223 ret = q.set_str ("4/5", 10); ASSERT_ALWAYS (ret == 0 && q == mpq_class(4,5));
224 ret = q.set_str ("7b", 16); ASSERT_ALWAYS (ret == 0 && q == 123);
225 ret = q.set_str ("7B", 16); ASSERT_ALWAYS (ret == 0 && q == 123);
226 ret = q.set_str ("0x7B", 0); ASSERT_ALWAYS (ret == 0 && q == 123);
227 ret = q.set_str ("0x10/17", 0); ASSERT_ALWAYS (ret == 0 && q == mpq_class(16,17));
228
229 ret = q.set_str (string("4/5"), 10); ASSERT_ALWAYS (ret == 0 && q == mpq_class(4,5));
230 ret = q.set_str (string("123"), 10); ASSERT_ALWAYS (ret == 0 && q == 123);
231 ret = q.set_str (string("7b"), 16); ASSERT_ALWAYS (ret == 0 && q == 123);
232 ret = q.set_str (string("7B"), 16); ASSERT_ALWAYS (ret == 0 && q == 123);
233 ret = q.set_str (string("0x7B"), 0); ASSERT_ALWAYS (ret == 0 && q == 123);
234 ret = q.set_str (string("0x10/17"), 0); ASSERT_ALWAYS (ret == 0 && q == mpq_class(16,17));
235 }
236 }
237
238 void
check_mpf(void)239 check_mpf (void)
240 {
241 // mpf_class::fits_sint_p
242 {
243 bool fits;
244 mpf_class f (0, 2*8*sizeof(int));
245 f = INT_MIN; fits = f.fits_sint_p(); ASSERT_ALWAYS (fits);
246 f--; fits = f.fits_sint_p(); ASSERT_ALWAYS (! fits);
247 f = INT_MAX; fits = f.fits_sint_p(); ASSERT_ALWAYS (fits);
248 f++; fits = f.fits_sint_p(); ASSERT_ALWAYS (! fits);
249 }
250
251 // mpf_class::fits_uint_p
252 {
253 bool fits;
254 mpf_class f (0, 2*8*sizeof(int));
255 f = 0; fits = f.fits_uint_p(); ASSERT_ALWAYS (fits);
256 f--; fits = f.fits_uint_p(); ASSERT_ALWAYS (! fits);
257 f = UINT_MAX; fits = f.fits_uint_p(); ASSERT_ALWAYS (fits);
258 f++; fits = f.fits_uint_p(); ASSERT_ALWAYS (! fits);
259 }
260
261 // mpf_class::fits_slong_p
262 {
263 bool fits;
264 mpf_class f (0, 2*8*sizeof(long));
265 f = LONG_MIN; fits = f.fits_slong_p(); ASSERT_ALWAYS (fits);
266 f--; fits = f.fits_slong_p(); ASSERT_ALWAYS (! fits);
267 f = LONG_MAX; fits = f.fits_slong_p(); ASSERT_ALWAYS (fits);
268 f++; fits = f.fits_slong_p(); ASSERT_ALWAYS (! fits);
269 }
270
271 // mpf_class::fits_ulong_p
272 {
273 bool fits;
274 mpf_class f (0, 2*8*sizeof(long));
275 f = 0; fits = f.fits_ulong_p(); ASSERT_ALWAYS (fits);
276 f--; fits = f.fits_ulong_p(); ASSERT_ALWAYS (! fits);
277 f = ULONG_MAX; fits = f.fits_ulong_p(); ASSERT_ALWAYS (fits);
278 f++; fits = f.fits_ulong_p(); ASSERT_ALWAYS (! fits);
279 }
280
281 // mpf_class::fits_sshort_p
282 {
283 bool fits;
284 mpf_class f (0, 2*8*sizeof(short));
285 f = SHRT_MIN; fits = f.fits_sshort_p(); ASSERT_ALWAYS (fits);
286 f--; fits = f.fits_sshort_p(); ASSERT_ALWAYS (! fits);
287 f = SHRT_MAX; fits = f.fits_sshort_p(); ASSERT_ALWAYS (fits);
288 f++; fits = f.fits_sshort_p(); ASSERT_ALWAYS (! fits);
289 }
290
291 // mpf_class::fits_ushort_p
292 {
293 bool fits;
294 mpf_class f (0, 2*8*sizeof(short));
295 f = 0; fits = f.fits_ushort_p(); ASSERT_ALWAYS (fits);
296 f--; fits = f.fits_ushort_p(); ASSERT_ALWAYS (! fits);
297 f = USHRT_MAX; fits = f.fits_ushort_p(); ASSERT_ALWAYS (fits);
298 f++; fits = f.fits_ushort_p(); ASSERT_ALWAYS (! fits);
299 }
300
301 // mpf_class::get_d
302 // mpf_class::get_si
303 // mpf_class::get_ui
304 {
305 mpf_class f(123);
306 { double d = f.get_d(); ASSERT_ALWAYS (d == 123.0); }
307 { long l = f.get_si(); ASSERT_ALWAYS (l == 123L); }
308 { long u = f.get_ui(); ASSERT_ALWAYS (u == 123L); }
309 }
310 {
311 mpf_class f(-123);
312 { double d = f.get_d(); ASSERT_ALWAYS (d == -123.0); }
313 { long l = f.get_si(); ASSERT_ALWAYS (l == -123L); }
314 }
315
316 // mpf_class::get_prec
317 {
318 mpf_class f;
319 ASSERT_ALWAYS (f.get_prec() == mpf_get_default_prec());
320 }
321
322 // mpf_class::get_str
323 {
324 mpf_class f(123);
325 string s;
326 mp_exp_t e;
327 s = f.get_str(e); ASSERT_ALWAYS (s == "123" && e == 3);
328 s = f.get_str(e, 16); ASSERT_ALWAYS (s == "7b" && e == 2);
329 s = f.get_str(e, -16); ASSERT_ALWAYS (s == "7B" && e == 2);
330 s = f.get_str(e, 10, 2); ASSERT_ALWAYS (s == "12" && e == 3);
331 s = f.get_str(e, 10, 1); ASSERT_ALWAYS (s == "1" && e == 3);
332 }
333
334 // mpf_class::set_str
335 {
336 mpf_class f;
337 int ret;
338 ret = f.set_str ("123", 10); ASSERT_ALWAYS (ret == 0 && f == 123);
339 ret = f.set_str ("123e1", 10); ASSERT_ALWAYS (ret == 0 && f == 1230);
340 ret = f.set_str ("1230e-1", 10); ASSERT_ALWAYS (ret == 0 && f == 123);
341 ret = f.set_str ("7b", 16); ASSERT_ALWAYS (ret == 0 && f == 123);
342 ret = f.set_str ("7B", 16); ASSERT_ALWAYS (ret == 0 && f == 123);
343 ret = f.set_str ("7B@1", 16); ASSERT_ALWAYS (ret == 0 && f == 1968);
344 ret = f.set_str ("7B0@-1", 16); ASSERT_ALWAYS (ret == 0 && f == 123);
345
346 ret = f.set_str (string("123"), 10); ASSERT_ALWAYS (ret == 0 && f == 123);
347 ret = f.set_str (string("123e1"), 10); ASSERT_ALWAYS (ret == 0 && f == 1230);
348 ret = f.set_str (string("1230e-1"), 10); ASSERT_ALWAYS (ret == 0 && f == 123);
349 ret = f.set_str (string("7b"), 16); ASSERT_ALWAYS (ret == 0 && f == 123);
350 ret = f.set_str (string("7B"), 16); ASSERT_ALWAYS (ret == 0 && f == 123);
351 ret = f.set_str (string("7B@1"), 16); ASSERT_ALWAYS (ret == 0 && f == 1968);
352 ret = f.set_str (string("7B0@-1"), 16); ASSERT_ALWAYS (ret == 0 && f == 123);
353 }
354
355 // mpf_class::set_prec
356 {
357 mpf_class f;
358 f.set_prec (256);
359 ASSERT_ALWAYS (f.get_prec () >= 256);
360 }
361
362 // mpf_class::set_prec_raw
363 {
364 mpf_class f (0, 100 * GMP_NUMB_BITS);
365 f.set_prec_raw (5 * GMP_NUMB_BITS);
366 ASSERT_ALWAYS (f.get_prec () >= 5 * GMP_NUMB_BITS);
367 ASSERT_ALWAYS (f.get_prec () < 100 * GMP_NUMB_BITS);
368 f.set_prec_raw (100 * GMP_NUMB_BITS);
369 }
370 }
371
372 // std::numeric_limits
373 void
check_limits(void)374 check_limits (void)
375 {
376 // Check that the content is not private.
377 ASSERT_ALWAYS ( std::numeric_limits<mpz_class>::is_integer);
378 ASSERT_ALWAYS (!std::numeric_limits<mpf_class>::is_integer);
379
380 // Check that symbols are emitted.
381 ASSERT_ALWAYS (&std::numeric_limits<mpz_class>::is_integer
382 != &std::numeric_limits<mpq_class>::is_integer);
383 }
384
385 int
main(void)386 main (void)
387 {
388 tests_start();
389
390 check_mpz();
391 check_mpq();
392 check_mpf();
393 check_limits();
394
395 tests_end();
396 return 0;
397 }
398