1 /* Test file for mpfr_get_str.
2
3 Copyright 1999, 2001-2023 Free Software Foundation, Inc.
4 Contributed by the AriC and Caramba projects, INRIA.
5
6 This file is part of the GNU MPFR Library.
7
8 The GNU MPFR Library is free software; you can redistribute it and/or modify
9 it under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or (at your
11 option) any later version.
12
13 The GNU MPFR Library is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public
16 License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with the GNU MPFR Library; see the file COPYING.LESSER. If not, see
20 https://www.gnu.org/licenses/ or write to the Free Software Foundation, Inc.,
21 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA. */
22
23 #include "mpfr-test.h"
24
25 static void
check3(const char * d,mpfr_rnd_t rnd,const char * res)26 check3 (const char *d, mpfr_rnd_t rnd, const char *res)
27 {
28 mpfr_t x;
29 char *str;
30 mpfr_exp_t e;
31
32 mpfr_init2 (x, 53);
33 mpfr_set_str (x, d, 10, rnd);
34 str = mpfr_get_str (NULL, &e, 10, 5, x, rnd);
35 if (strcmp (str, res))
36 {
37 printf ("Error in mpfr_get_str for x=%s\n", d);
38 printf ("got %s instead of %s\n", str, res);
39 exit (1);
40 }
41 mpfr_clear (x);
42 mpfr_free_str (str);
43 }
44
45 static void
check_small(void)46 check_small (void)
47 {
48 mpfr_t x;
49 char *s;
50 mpfr_exp_t e;
51 mpfr_prec_t p;
52
53 mpfr_init (x);
54
55 mpfr_set_prec (x, 20);
56 mpfr_set_ui (x, 2, MPFR_RNDN);
57 mpfr_nexttozero (x);
58 s = mpfr_get_str (NULL, &e, 4, 2, x, MPFR_RNDU);
59 if (strcmp (s, "20") || (e != 1))
60 {
61 printf ("Error in mpfr_get_str: 2- rounded up with 2 digits"
62 " in base 4\n");
63 exit (1);
64 }
65 mpfr_free_str (s);
66
67 /* check n_digits=0 */
68 mpfr_set_prec (x, 5);
69 mpfr_set_ui (x, 17, MPFR_RNDN);
70 s = mpfr_get_str (NULL, &e, 3, 0, x, MPFR_RNDN);
71 mpfr_free_str (s);
72 s = mpfr_get_str (NULL, &e, 36, 0, x, MPFR_RNDN);
73 mpfr_free_str (s);
74 s = mpfr_get_str (NULL, &e, 62, 0, x, MPFR_RNDN);
75 mpfr_free_str (s);
76
77 mpfr_set_prec (x, 64);
78 mpfr_set_si (x, -1, MPFR_RNDN);
79 mpfr_div_2ui (x, x, 63, MPFR_RNDN); /* x = -2^(-63) */
80 mpfr_add_ui (x, x, 1, MPFR_RNDN); /* x = 1 - 2^(-63) */
81 mpfr_mul_2ui (x, x, 32, MPFR_RNDN); /* x = 2^32 - 2^(-31) */
82 s = mpfr_get_str (NULL, &e, 3, 21, x, MPFR_RNDU);
83 if (strcmp (s, "102002022201221111211") || (e != 21))
84 {
85 printf ("Error in mpfr_get_str: 2^32-2^(-31) rounded up with"
86 " 21 digits in base 3\n");
87 exit (1);
88 }
89 mpfr_free_str (s);
90 s = mpfr_get_str (NULL, &e, 3, 20, x, MPFR_RNDU);
91 if (strcmp (s, "10200202220122111122") || (e != 21))
92 {
93 printf ("Error in mpfr_get_str: 2^32-2^(-31) rounded up with"
94 " 20 digits in base 3\n");
95 exit (1);
96 }
97 mpfr_free_str (s);
98
99 /* check corner case ret!=0, j0!=0 in mpfr_get_str_aux */
100 mpfr_set_prec (x, 100);
101 mpfr_set_str_binary (x, "0.1001011111010001101110010101010101111001010111111101101101100110100011110110000101110110001011110000E-9");
102 s = mpfr_get_str (NULL, &e, 3, 2, x, MPFR_RNDU);
103 if (strcmp (s, "22") || (e != -6))
104 {
105 printf ("Error in mpfr_get_str: 100-bit number rounded up with"
106 " 2 digits in base 3\n");
107 exit (1);
108 }
109 mpfr_free_str (s);
110
111 /* check corner case exact=0 in mpfr_get_str_aux */
112 mpfr_set_prec (x, 100);
113 mpfr_set_str_binary (x, "0.1001001111101101111000101000110111111010101100000110010001111111011001101011101100001100110000000000E8");
114 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDZ);
115 if (strcmp (s, "14") || (e != 3))
116 {
117 printf ("Error in mpfr_get_str: 100-bit number rounded to zero with"
118 " 2 digits in base 10\n");
119 exit (1);
120 }
121 mpfr_free_str (s);
122
123 for (p=4; p<=200; p++)
124 {
125 mpfr_set_prec (x, p);
126 mpfr_set_str (x, "6.5", 10, MPFR_RNDN);
127
128 s = mpfr_get_str (NULL, &e, 6, 2, x, MPFR_RNDN);
129 if (strcmp (s, "10") || (e != 2))
130 {
131 printf ("Error in mpfr_get_str: 6.5 rounded to nearest with"
132 " 2 digits in base 6\n");
133 exit (1);
134 }
135 mpfr_free_str (s);
136
137 mpfr_nexttoinf (x);
138 s = mpfr_get_str (NULL, &e, 6, 2, x, MPFR_RNDN);
139 if (strcmp (s, "11") || (e != 2))
140 {
141 printf ("Error in mpfr_get_str: 6.5+ rounded to nearest with"
142 " 2 digits in base 6\ngot %se%d instead of 11e2\n",
143 s, (int) e);
144 exit (1);
145 }
146 mpfr_free_str (s);
147
148 mpfr_set_str (x, "6.5", 10, MPFR_RNDN);
149 mpfr_nexttozero (x);
150 s = mpfr_get_str (NULL, &e, 6, 2, x, MPFR_RNDN);
151 if (strcmp (s, "10") || (e != 2))
152 {
153 printf ("Error in mpfr_get_str: 6.5- rounded to nearest with"
154 " 2 digits in base 6\n");
155 exit (1);
156 }
157 mpfr_free_str (s);
158 }
159
160 mpfr_set_prec (x, 3);
161 mpfr_set_ui (x, 7, MPFR_RNDN);
162 s = mpfr_get_str (NULL, &e, 2, 2, x, MPFR_RNDU);
163 if (strcmp (s, "10") || (e != 4))
164 {
165 printf ("Error in mpfr_get_str: 7 rounded up with 2 bits should"
166 " give 0.10e3 instead of 0.%s*2^%d\n", s, (int) e);
167 exit (1);
168 }
169 mpfr_free_str (s);
170
171 /* problem found by Fabrice Rouillier */
172 mpfr_set_prec (x, 63);
173 mpfr_set_str (x, "5e14", 10, MPFR_RNDN);
174 s = mpfr_get_str (NULL, &e, 10, 18, x, MPFR_RNDU);
175 mpfr_free_str (s);
176
177 /* bug found by Johan Vervloet */
178 mpfr_set_prec (x, 6);
179 mpfr_set_str (x, "688.0", 10, MPFR_RNDN);
180 s = mpfr_get_str (NULL, &e, 2, 4, x, MPFR_RNDU);
181 if (strcmp (s, "1011") || (e != 10))
182 {
183 printf ("Error in mpfr_get_str: 688 printed up to 4 bits should"
184 " give 1.011e9\ninstead of ");
185 mpfr_out_str (stdout, 2, 4, x, MPFR_RNDU);
186 puts ("");
187 exit (1);
188 }
189 mpfr_free_str (s);
190
191 mpfr_set_prec (x, 38);
192 mpfr_set_str_binary (x, "1.0001110111110100011010100010010100110e-6");
193 s = mpfr_get_str (NULL, &e, 8, 10, x, MPFR_RNDU);
194 if (strcmp (s, "1073721522") || (e != -1))
195 {
196 printf ("Error in mpfr_get_str (3): s=%s e=%d\n", s, (int) e);
197 exit (1);
198 }
199 mpfr_free_str (s);
200
201 mpfr_set_prec (x, 53);
202 mpfr_set_str_binary (x, "0.11010111011101100010000100010101110001000000010111001E454");
203 s = mpfr_get_str (NULL, &e, 19, 12, x, MPFR_RNDU);
204 if (strcmp (s, "b1cgfa4gha0h") || (e != 107))
205 {
206 printf ("Error in mpfr_get_str (4): s=%s e=%d\n", s, (int) e);
207 exit (1);
208 }
209 mpfr_free_str (s);
210
211 mpfr_set_prec (x, 145);
212 mpfr_set_str_binary (x, "-0.1000110011000001011000010101101010110110101100101110100011111100011110011001001001010000100001000011000011000000010111011001000111101001110100110e6");
213 s = mpfr_get_str (NULL, &e, 4, 53, x, MPFR_RNDU);
214 if (strcmp (s, "-20303001120111222312230232203330132121021100201003003") || (e != 3))
215 {
216 printf ("Error in mpfr_get_str (5): s=%s e=%d\n", s, (int) e);
217 exit (1);
218 }
219 mpfr_free_str (s);
220
221 mpfr_set_prec (x, 45);
222 mpfr_set_str_binary (x, "-0.00100111010110010001011001110111010001010010010");
223 s = mpfr_get_str (NULL, &e, 32, 9, x, MPFR_RNDN);
224 if (strcmp (s, "-4tchctq54") || (e != 0))
225 {
226 printf ("Error in mpfr_get_str (6): s=%s e=%d\n", s, (int) e);
227 exit (1);
228 }
229 mpfr_free_str (s);
230
231 /* worst case found by Vincent Lefe`vre */
232 mpfr_set_prec (x, 53);
233 mpfr_set_str_binary (x, "10011110111100000000001011011110101100010000011011111E164");
234 s = mpfr_get_str (NULL, &e, 10, 17, x, MPFR_RNDN);
235 if (strcmp (s, "13076622631878654") || (e != 66))
236 {
237 printf ("Error in mpfr_get_str (7): s=%s e=%d\n", s, (int) e);
238 exit (1);
239 }
240 mpfr_free_str (s);
241 mpfr_set_str_binary (x, "10000001001001001100011101010011011011111000011000100E93");
242 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDU);
243 if (strcmp (s, "46") || e != 44)
244 {
245 printf ("Error in mpfr_get_str (8): s=%s e=%d\n", s, (int) e);
246 exit (1);
247 }
248 mpfr_free_str (s);
249 mpfr_set_str_binary (x, "10010001111100000111001111010101001010000010111010101E55");
250 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDN);
251 if (strcmp (s, "19") || e != 33)
252 {
253 printf ("Error in mpfr_get_str (9): s=%s e=%d\n", s, (int) e);
254 exit (1);
255 }
256 mpfr_free_str (s);
257 mpfr_set_str_binary (x, "11011001010010111110010101101100111110111000010110110E44");
258 s = mpfr_get_str (NULL, &e, 10, 3, x, MPFR_RNDN);
259 if (strcmp (s, "135") || e != 30)
260 {
261 printf ("Error in mpfr_get_str (10): s=%s e=%d\n", s, (int) e);
262 exit (1);
263 }
264 mpfr_free_str (s);
265 mpfr_set_str_binary (x, "11101111101000001011100001111000011111101111011001100E72");
266 s = mpfr_get_str (NULL, &e, 10, 4, x, MPFR_RNDN);
267 if (strcmp (s, "3981") || e != 38)
268 {
269 printf ("Error in mpfr_get_str (11): s=%s e=%d\n", s, (int) e);
270 exit (1);
271 }
272 mpfr_free_str (s);
273 mpfr_set_str_binary (x, "10011001001100100010111100001101110101001001111110000E46");
274 s = mpfr_get_str (NULL, &e, 10, 5, x, MPFR_RNDN);
275 if (strcmp (s, "37930") || e != 30)
276 {
277 printf ("Error in mpfr_get_str (12): s=%s e=%d\n", s, (int) e);
278 exit (1);
279 }
280 mpfr_free_str (s);
281 mpfr_set_str_binary (x, "10001100110111001011011110011011011101100011010001011E-72");
282 s = mpfr_get_str (NULL, &e, 10, 6, x, MPFR_RNDN);
283 if (strcmp (s, "104950") || e != -5)
284 {
285 printf ("Error in mpfr_get_str (13): s=%s e=%d\n", s, (int) e);
286 exit (1);
287 }
288 mpfr_free_str (s);
289
290 mpfr_set_str_binary (x, "10100100001011001000011001101101000110100110000010111E89");
291 s = mpfr_get_str (NULL, &e, 10, 7, x, MPFR_RNDN);
292 if (strcmp (s, "3575392") || e != 43)
293 {
294 printf ("Error in mpfr_get_str (14): s=%s e=%d\n", s, (int) e);
295 exit (1);
296 }
297 mpfr_free_str (s);
298
299 mpfr_set_str_binary (x, "11000011011110110010100110001010000001010011001011001E-73");
300 s = mpfr_get_str (NULL, &e, 10, 8, x, MPFR_RNDN);
301 if (strcmp (s, "72822386") || e != -6)
302 {
303 printf ("Error in mpfr_get_str (15): s=%s e=%d\n", s, (int) e);
304 exit (1);
305 }
306 mpfr_free_str (s);
307
308 mpfr_set_str_binary (x, "10101010001101000111001100001000100011100010010001010E78");
309 s = mpfr_get_str (NULL, &e, 10, 9, x, MPFR_RNDN);
310 if (strcmp (s, "180992873") || e != 40)
311 {
312 printf ("Error in mpfr_get_str (16): s=%s e=%d\n", s, (int) e);
313 exit (1);
314 }
315 mpfr_free_str (s);
316
317 mpfr_set_str_binary (x, "10110111001000100000001101111001100101101110011011101E91");
318 s = mpfr_get_str (NULL, &e, 10, 10, x, MPFR_RNDN);
319 if (strcmp (s, "1595312255") || e != 44)
320 {
321 printf ("Error in mpfr_get_str (17): s=%s e=%d\n", s, (int) e);
322 exit (1);
323 }
324 mpfr_free_str (s);
325 mpfr_set_str_binary (x, "10011101010111101111000100111011101011110100110110101E93");
326 s = mpfr_get_str (NULL, &e, 10, 11, x, MPFR_RNDN);
327 if (strcmp (s, "54835744350") || e != 44)
328 {
329 printf ("Error in mpfr_get_str (18): s=%s e=%d\n", s, (int) e);
330 exit (1);
331 }
332 mpfr_free_str (s);
333 mpfr_set_str_binary (x, "10011101010111101111000100111011101011110100110110101E92");
334 s = mpfr_get_str (NULL, &e, 10, 12, x, MPFR_RNDN);
335 if (strcmp (s, "274178721752") || e != 44)
336 {
337 printf ("Error in mpfr_get_str (19): s=%s e=%d\n", s, (int) e);
338 exit (1);
339 }
340 mpfr_free_str (s);
341 mpfr_set_str_binary (x, "10011101010111101111000100111011101011110100110110101E91");
342 s = mpfr_get_str (NULL, &e, 10, 13, x, MPFR_RNDN);
343 if (strcmp (s, "1370893608762") || e != 44)
344 {
345 printf ("Error in mpfr_get_str (20): s=%s e=%d\n", s, (int) e);
346 exit (1);
347 }
348 mpfr_free_str (s);
349
350 mpfr_set_str_binary (x, "10010011010110011100010010100101100011101000011111111E92");
351 s = mpfr_get_str (NULL, &e, 10, 14, x, MPFR_RNDN);
352 if (strcmp (s, "25672105101864") || e != 44)
353 {
354 printf ("Error in mpfr_get_str (21): s=%s e=%d\n", s, (int) e);
355 exit (1);
356 }
357 mpfr_free_str (s);
358
359 mpfr_set_str_binary (x, "100110111110110001000101110100100101101000011111001E87");
360 s = mpfr_get_str (NULL, &e, 10, 15, x, MPFR_RNDN);
361 if (strcmp (s, "212231308858721") || e != 42)
362 {
363 printf ("Error in mpfr_get_str (22): s=%s e=%d\n", s, (int) e);
364 exit (1);
365 }
366 mpfr_free_str (s);
367 mpfr_set_str_binary (x, "10111010110000111000101100101111001011011100101001111E-128");
368 s = mpfr_get_str (NULL, &e, 10, 15, x, MPFR_RNDN);
369 if (strcmp (s, "193109287087290") || e != -22)
370 {
371 printf ("Error in mpfr_get_str (22b): s=%s e=%d\n", s, (int) e);
372 exit (1);
373 }
374 mpfr_free_str (s);
375
376 mpfr_set_str_binary (x, "10001101101011010001111110000111010111010000110101010E80");
377 s = mpfr_get_str (NULL, &e, 10, 16, x, MPFR_RNDN);
378 if (strcmp (s, "6026241735727920") || e != 40)
379 {
380 printf ("Error in mpfr_get_str (23): s=%s e=%d\n", s, (int) e);
381 exit (1);
382 }
383 mpfr_free_str (s);
384
385 mpfr_set_str_binary (x, "100010001011101001110101000110011001001000110001001E-81");
386 s = mpfr_get_str (NULL, &e, 10, 17, x, MPFR_RNDN);
387 if (strcmp (s, "49741483709103481") || e != -9)
388 {
389 printf ("Error in mpfr_get_str (24): s=%s e=%d\n", s, (int) e);
390 exit (1);
391 }
392 mpfr_free_str (s);
393 mpfr_set_str_binary (x, "11000100001001001110111010011001111001001010110101111E-101");
394 s = mpfr_get_str (NULL, &e, 10, 7, x, MPFR_RNDN);
395 if (strcmp (s, "2722049") || e != -14)
396 {
397 printf ("Error in mpfr_get_str (25): s=%s e=%d\n", s, (int) e);
398 exit (1);
399 }
400 mpfr_free_str (s);
401 mpfr_set_str_binary (x, "11111001010011100101000001111111110001001001110110001E-135");
402 s = mpfr_get_str (NULL, &e, 10, 8, x, MPFR_RNDN);
403 if (strcmp (s, "20138772") || e != -24)
404 {
405 printf ("Error in mpfr_get_str (26): s=%s e=%d\n", s, (int) e);
406 exit (1);
407 }
408 mpfr_free_str (s);
409
410 mpfr_set_str_binary (x, "11111001010011100101000001111111110001001001110110001E-136");
411 s = mpfr_get_str (NULL, &e, 10, 9, x, MPFR_RNDN);
412 if (strcmp (s, "100693858") || e != -24)
413 {
414 printf ("Error in mpfr_get_str (27): s=%s e=%d\n", s, (int) e);
415 exit (1);
416 }
417 mpfr_free_str (s);
418 mpfr_set_str_binary (x, "10001000001110010110001011111011111011011010000110001E-110");
419 s = mpfr_get_str (NULL, &e, 10, 14, x, MPFR_RNDN);
420 if (strcmp (s, "36923634350619") || e != -17)
421 {
422 printf ("Error in mpfr_get_str (28): s=%s e=%d\n", s, (int) e);
423 exit (1);
424 }
425 mpfr_free_str (s);
426 mpfr_set_str_binary (x, "11001100010111000111100010000110011101110001000101111E-87");
427 s = mpfr_get_str (NULL, &e, 10, 16, x, MPFR_RNDN);
428 if (strcmp (s, "4646636036100804") || e != -10)
429 {
430 printf ("Error in mpfr_get_str (29): s=%s e=%d\n", s, (int) e);
431 exit (1);
432 }
433 mpfr_free_str (s);
434 mpfr_set_str_binary (x, "10011111001111110100001001010111111011010101111111000E-99");
435 s = mpfr_get_str (NULL, &e, 10, 17, x, MPFR_RNDN);
436 if (strcmp (s, "88399901882446712") || e != -14)
437 {
438 printf ("Error in mpfr_get_str (30): s=%s e=%d\n", s, (int) e);
439 exit (1);
440 }
441 mpfr_free_str (s);
442
443 /* 8116315218207718*2^(-293) ~ 0.5100000000000000000015*10^(-72) */
444 mpfr_set_str_binary (x, "11100110101011011111011100101011101110110001111100110E-293");
445 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDU);
446 if (strcmp (s, "52") || e != -72)
447 {
448 printf ("Error in mpfr_get_str (31u): s=%s e=%d\n", s, (int) e);
449 exit (1);
450 }
451 mpfr_free_str (s);
452 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDD);
453 if (strcmp (s, "51") || e != -72)
454 {
455 printf ("Error in mpfr_get_str (31d): s=%s e=%d\n", s, (int) e);
456 exit (1);
457 }
458 mpfr_free_str (s);
459
460 /* 6712731423444934*2^536 ~ .151000000000000000000067*10^178 */
461 mpfr_set_str_binary (x, "10111110110010011000110010011111101111000111111000110E536");
462 s = mpfr_get_str (NULL, &e, 10, 3, x, MPFR_RNDU);
463 if (strcmp (s, "152") || e != 178)
464 {
465 printf ("Error in mpfr_get_str (32u): s=%s e=%d\n", s, (int) e);
466 exit (1);
467 }
468 mpfr_free_str (s);
469 s = mpfr_get_str (NULL, &e, 10, 3, x, MPFR_RNDD);
470 if (strcmp (s, "151") || e != 178)
471 {
472 printf ("Error in mpfr_get_str (32d): s=%s e=%d\n", s, (int) e);
473 exit (1);
474 }
475 mpfr_free_str (s);
476
477 /* 3356365711722467*2^540 ~ .120800000000000000000054*10^179 */
478 mpfr_set_str_binary (x, "1011111011001001100011001001111110111100011111100011E540");
479 s = mpfr_get_str (NULL, &e, 10, 4, x, MPFR_RNDU);
480 if (strcmp (s, "1209") || e != 179)
481 {
482 printf ("Error in mpfr_get_str (33u): s=%s e=%d\n", s, (int) e);
483 exit (1);
484 }
485 mpfr_free_str (s);
486 s = mpfr_get_str (NULL, &e, 10, 4, x, MPFR_RNDD);
487 if (strcmp (s, "1208") || e != 179)
488 {
489 printf ("Error in mpfr_get_str (33d): s=%s e=%d\n", s, (int) e);
490 exit (1);
491 }
492 mpfr_free_str (s);
493
494 /* 6475049196144587*2^100 ~ .8208099999999999999999988*10^46 */
495 mpfr_set_str_binary (x, "10111000000010000010111011111001111010100011111001011E100");
496 s = mpfr_get_str (NULL, &e, 10, 5, x, MPFR_RNDU);
497 if (strcmp (s, "82081") || e != 46)
498 {
499 printf ("Error in mpfr_get_str (34u): s=%s e=%d\n", s, (int) e);
500 exit (1);
501 }
502 mpfr_free_str (s);
503 s = mpfr_get_str (NULL, &e, 10, 5, x, MPFR_RNDD);
504 if (strcmp (s, "82080") || e != 46)
505 {
506 printf ("Error in mpfr_get_str (34d): s=%s e=%d\n", s, (int) e);
507 exit (1);
508 }
509 mpfr_free_str (s);
510
511 /* 6722280709661868*2^364 ~ .25260100000000000000000012*10^126 */
512 mpfr_set_str_binary (x, "10111111000011110000011110001110001111010010010101100E364");
513 s = mpfr_get_str (NULL, &e, 10, 6, x, MPFR_RNDU);
514 if (strcmp (s, "252602") || e != 126)
515 {
516 printf ("Error in mpfr_get_str (35u): s=%s e=%d\n", s, (int) e);
517 exit (1);
518 }
519 mpfr_free_str (s);
520 s = mpfr_get_str (NULL, &e, 10, 6, x, MPFR_RNDD);
521 if (strcmp (s, "252601") || e != 126)
522 {
523 printf ("Error in mpfr_get_str (35d): s=%s e=%d\n", s, (int) e);
524 exit (1);
525 }
526 mpfr_free_str (s);
527
528 /* 5381065484265332*2^(-455) ~ .578389299999999999999999982*10^(-121) */
529 mpfr_set_str_binary (x, "10011000111100000110011110000101100111110011101110100E-455");
530 s = mpfr_get_str (NULL, &e, 10, 7, x, MPFR_RNDU);
531 if (strcmp (s, "5783893") || e != -121)
532 {
533 printf ("Error in mpfr_get_str (36u): s=%s e=%d\n", s, (int) e);
534 exit (1);
535 }
536 mpfr_free_str (s);
537 s = mpfr_get_str (NULL, &e, 10, 7, x, MPFR_RNDD);
538 if (strcmp (s, "5783892") || e != -121)
539 {
540 printf ("Error in mpfr_get_str (36d): s=%s e=%d\n", s, (int) e);
541 exit (1);
542 }
543 mpfr_free_str (s);
544
545 /* 8369123604277281*2^(-852) ~ .27869147000000000000000000056*10^(-240) */
546 mpfr_set_str_binary (x, "11101101110111010110001101111100000111010100000100001E-852");
547 s = mpfr_get_str (NULL, &e, 10, 8, x, MPFR_RNDU);
548 if (strcmp (s, "27869148") || e != -240)
549 {
550 printf ("Error in mpfr_get_str (37u): s=%s e=%d\n", s, (int) e);
551 exit (1);
552 }
553 mpfr_free_str (s);
554 s = mpfr_get_str (NULL, &e, 10, 8, x, MPFR_RNDD);
555 if (strcmp (s, "27869147") || e != -240)
556 {
557 printf ("Error in mpfr_get_str (37d): s=%s e=%d\n", s, (int) e);
558 exit (1);
559 }
560 mpfr_free_str (s);
561
562 /* 7976538478610756*2^377 ~ .245540326999999999999999999982*10^130 */
563 mpfr_set_str_binary (x, "11100010101101001111010010110100011100000100101000100E377");
564 s = mpfr_get_str (NULL, &e, 10, 9, x, MPFR_RNDU);
565 if (strcmp (s, "245540327") || e != 130)
566 {
567 printf ("Error in mpfr_get_str (38u): s=%s e=%d\n", s, (int) e);
568 exit (1);
569 }
570 mpfr_free_str (s);
571 s = mpfr_get_str (NULL, &e, 10, 9, x, MPFR_RNDD);
572 if (strcmp (s, "245540326") || e != 130)
573 {
574 printf ("Error in mpfr_get_str (38d): s=%s e=%d\n", s, (int) e);
575 exit (1);
576 }
577 mpfr_free_str (s);
578
579 /* 8942832835564782*2^(-382) ~ .9078555839000000000000000000038*10^(-99) */
580 mpfr_set_str_binary (x, "11111110001010111010110000110011100110001010011101110E-382");
581 s = mpfr_get_str (NULL, &e, 10, 10, x, MPFR_RNDU);
582 if (strcmp (s, "9078555840") || e != -99)
583 {
584 printf ("Error in mpfr_get_str (39u): s=%s e=%d\n", s, (int) e);
585 exit (1);
586 }
587 mpfr_free_str (s);
588 s = mpfr_get_str (NULL, &e, 10, 10, x, MPFR_RNDD);
589 if (strcmp (s, "9078555839") || e != -99)
590 {
591 printf ("Error in mpfr_get_str (39d): s=%s e=%d\n", s, (int) e);
592 exit (1);
593 }
594 mpfr_free_str (s);
595
596 /* 4471416417782391*2^(-380) ~ .18157111678000000000000000000077*10^(-98) */
597 mpfr_set_str_binary (x, "1111111000101011101011000011001110011000101001110111E-380");
598 s = mpfr_get_str (NULL, &e, 10, 11, x, MPFR_RNDU);
599 if (strcmp (s, "18157111679") || e != -98)
600 {
601 printf ("Error in mpfr_get_str (40u): s=%s e=%d\n", s, (int) e);
602 exit (1);
603 }
604 mpfr_free_str (s);
605 s = mpfr_get_str (NULL, &e, 10, 11, x, MPFR_RNDD);
606 if (strcmp (s, "18157111678") || e != -98)
607 {
608 printf ("Error in mpfr_get_str (40d): s=%s e=%d\n", s, (int) e);
609 exit (1);
610 }
611 mpfr_free_str (s);
612
613 /* 7225450889282194*2^711 ~ .778380362292999999999999999999971*10^230 */
614 mpfr_set_str_binary (x, "11001101010111000001001100001100110010000001010010010E711");
615 s = mpfr_get_str (NULL, &e, 10, 12, x, MPFR_RNDU);
616 if (strcmp (s, "778380362293") || e != 230)
617 {
618 printf ("Error in mpfr_get_str (41u): s=%s e=%d\n", s, (int) e);
619 exit (1);
620 }
621 mpfr_free_str (s);
622 s = mpfr_get_str (NULL, &e, 10, 12, x, MPFR_RNDD);
623 if (strcmp (s, "778380362292") || e != 230)
624 {
625 printf ("Error in mpfr_get_str (41d): s=%s e=%d\n", s, (int) e);
626 exit (1);
627 }
628 mpfr_free_str (s);
629
630 /* 3612725444641097*2^713 ~ .1556760724585999999999999999999942*10^231 */
631 mpfr_set_str_binary (x, "1100110101011100000100110000110011001000000101001001E713");
632 s = mpfr_get_str (NULL, &e, 10, 13, x, MPFR_RNDU);
633 if (strcmp (s, "1556760724586") || e != 231)
634 {
635 printf ("Error in mpfr_get_str (42u): s=%s e=%d\n", s, (int) e);
636 exit (1);
637 }
638 mpfr_free_str (s);
639 s = mpfr_get_str (NULL, &e, 10, 13, x, MPFR_RNDD);
640 if (strcmp (s, "1556760724585") || e != 231)
641 {
642 printf ("Error in mpfr_get_str (42d): s=%s e=%d\n", s, (int) e);
643 exit (1);
644 }
645 mpfr_free_str (s);
646
647 /* 6965949469487146*2^(-248) ~ .15400733123779000000000000000000016*10^(-58) */
648 mpfr_set_str_binary (x, "11000101111110111111001111111101001101111000000101010E-248");
649 s = mpfr_get_str (NULL, &e, 10, 14, x, MPFR_RNDU);
650 if (strcmp (s, "15400733123780") || e != -58)
651 {
652 printf ("Error in mpfr_get_str (43u): s=%s e=%d\n", s, (int) e);
653 exit (1);
654 }
655 mpfr_free_str (s);
656 s = mpfr_get_str (NULL, &e, 10, 14, x, MPFR_RNDD);
657 if (strcmp (s, "15400733123779") || e != -58)
658 {
659 printf ("Error in mpfr_get_str (43d): s=%s e=%d\n", s, (int) e);
660 exit (1);
661 }
662 mpfr_free_str (s);
663
664 /* 3482974734743573*2^(-244) ~ .12320586499023200000000000000000013*10^(-57) */
665 mpfr_set_str_binary (x, "1100010111111011111100111111110100110111100000010101E-244");
666 s = mpfr_get_str (NULL, &e, 10, 15, x, MPFR_RNDU);
667 if (strcmp (s, "123205864990233") || e != -57)
668 {
669 printf ("Error in mpfr_get_str (44u): s=%s e=%d\n", s, (int) e);
670 exit (1);
671 }
672 mpfr_free_str (s);
673 s = mpfr_get_str (NULL, &e, 10, 15, x, MPFR_RNDD);
674 if (strcmp (s, "123205864990232") || e != -57)
675 {
676 printf ("Error in mpfr_get_str (44d): s=%s e=%d\n", s, (int) e);
677 exit (1);
678 }
679 mpfr_free_str (s);
680
681 /* 7542952370752766*2^(-919) ~ .170206189963739699999999999999999974*10^(-260) */
682 mpfr_set_str_binary (x, "11010110011000100011001110100100111011100110011111110E-919");
683 s = mpfr_get_str (NULL, &e, 10, 16, x, MPFR_RNDU);
684 if (strcmp (s, "1702061899637397") || e != -260)
685 {
686 printf ("Error in mpfr_get_str (45u): s=%s e=%d\n", s, (int) e);
687 exit (1);
688 }
689 mpfr_free_str (s);
690 s = mpfr_get_str (NULL, &e, 10, 16, x, MPFR_RNDD);
691 if (strcmp (s, "1702061899637396") || e != -260)
692 {
693 printf ("Error in mpfr_get_str (45d): s=%s e=%d\n", s, (int) e);
694 exit (1);
695 }
696 mpfr_free_str (s);
697
698 /* 5592117679628511*2^165 ~ .26153245263757307000000000000000000074*10^66 */
699 mpfr_set_str_binary (x, "10011110111100000000001011011110101100010000011011111E165");
700 s = mpfr_get_str (NULL, &e, 10, 17, x, MPFR_RNDU);
701 if (strcmp (s, "26153245263757308") || e != 66)
702 {
703 printf ("Error in mpfr_get_str (46u): s=%s e=%d\n", s, (int) e);
704 exit (1);
705 }
706 mpfr_free_str (s);
707 s = mpfr_get_str (NULL, &e, 10, 17, x, MPFR_RNDD);
708 if (strcmp (s, "26153245263757307") || e != 66)
709 {
710 printf ("Error in mpfr_get_str (46d): s=%s e=%d\n", s, (int) e);
711 exit (1);
712 }
713 mpfr_free_str (s);
714
715 mpfr_set_str_binary (x, "11010010110111100001011010000110010000100001011011101E1223");
716 s = mpfr_get_str (NULL, &e, 10, 17, x, MPFR_RNDN);
717 if (strcmp (s, "10716284017294180") || e != 385)
718 {
719 printf ("Error in mpfr_get_str (47n): s=%s e=%d\n", s, (int) e);
720 exit (1);
721 }
722 mpfr_free_str (s);
723 s = mpfr_get_str (NULL, &e, 10, 18, x, MPFR_RNDU);
724 if (strcmp (s, "107162840172941805") || e != 385)
725 {
726 printf ("Error in mpfr_get_str (47u): s=%s e=%d\n", s, (int) e);
727 exit (1);
728 }
729 mpfr_free_str (s);
730 s = mpfr_get_str (NULL, &e, 10, 18, x, MPFR_RNDD);
731 if (strcmp (s, "107162840172941804") || e != 385)
732 {
733 printf ("Error in mpfr_get_str (47d): s=%s e=%d\n", s, (int) e);
734 exit (1);
735 }
736 mpfr_free_str (s);
737
738 mpfr_set_str_binary (x, "11111101111011000001010100001101101000010010001111E122620");
739 s = mpfr_get_str (NULL, &e, 10, 17, x, MPFR_RNDN);
740 if (strcmp (s, "22183435284042374") || e != 36928)
741 {
742 printf ("Error in mpfr_get_str (48n): s=%s e=%ld\n", s, (long) e);
743 exit (1);
744 }
745 mpfr_free_str (s);
746 s = mpfr_get_str (NULL, &e, 10, 18, x, MPFR_RNDU);
747 if (strcmp (s, "221834352840423736") || e != 36928)
748 {
749 printf ("Error in mpfr_get_str (48u): s=%s e=%ld\n", s, (long) e);
750 exit (1);
751 }
752 mpfr_free_str (s);
753 s = mpfr_get_str (NULL, &e, 10, 18, x, MPFR_RNDD);
754 if (strcmp (s, "221834352840423735") || e != 36928)
755 {
756 printf ("Error in mpfr_get_str (48d): s=%s e=%ld\n", s, (long) e);
757 exit (1);
758 }
759 mpfr_free_str (s);
760
761 mpfr_set_prec (x, 45);
762 mpfr_set_str_binary (x, "1E45");
763 s = mpfr_get_str (NULL, &e, 32, 9, x, MPFR_RNDN);
764 mpfr_free_str (s);
765
766 mpfr_set_prec (x, 7);
767 mpfr_set_str_binary (x, "0.1010101E10");
768 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDU);
769 mpfr_free_str (s);
770
771 /* checks rounding of negative numbers */
772 mpfr_set_prec (x, 7);
773 mpfr_set_str (x, "-11.5", 10, MPFR_RNDN);
774 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDD);
775 if (strcmp (s, "-12"))
776 {
777 printf ("Error in mpfr_get_str for x=-11.5 and rnd=MPFR_RNDD\n"
778 "got %s instead of -12\n", s);
779 exit (1);
780 }
781 mpfr_free_str (s);
782
783 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDU);
784 if (strcmp (s, "-11"))
785 {
786 printf ("Error in mpfr_get_str for x=-11.5 and rnd=MPFR_RNDU\n");
787 exit (1);
788 }
789 mpfr_free_str (s);
790
791 /* bug found by Jean-Pierre Merlet, produced error in mpfr_get_str */
792 mpfr_set_prec (x, 128);
793 mpfr_set_str_binary (x, "0.10111001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011001100110011010E3");
794 s = mpfr_get_str (NULL, &e, 10, 0, x, MPFR_RNDU);
795 mpfr_free_str (s);
796
797 mpfr_set_prec (x, 381);
798 mpfr_set_str_binary (x, "0.111111111111111111111111111111111111111111111111111111111111111111101110110000100110011101101101001010111000101111000100100011110101010110101110100000010100001000110100000100011111001000010010000010001010111001011110000001110010111101100001111000101101100000010110000101100100000101010110010110001010100111001111100011100101100000100100111001100010010011110011011010110000001000010");
799 s = mpfr_get_str (NULL, &e, 10, 0, x, MPFR_RNDD);
800 if (e != 0)
801 {
802 printf ("Error in mpfr_get_str for x=0.999999..., exponent is %d"
803 " instead of 0\n", (int) e);
804 exit (1);
805 }
806 mpfr_free_str (s);
807
808 mpfr_set_prec (x, 5);
809 mpfr_set_str_binary (x, "1101.1"); /* 13.5, or (16)_7 + 1/2 */
810 s = mpfr_get_str (NULL, &e, 7, 2, x, MPFR_RNDN);
811 /* we are in the tie case: both surrounding numbers are (16)_7 and
812 (20)_7: since (16)_7 = 13 is odd and (20)_7 = 14 is even,
813 we should have s = "20" and e = 2 */
814 if (e != 2 || strcmp (s, "20"))
815 {
816 printf ("Error in mpfr_get_str for x=13.5, base 7\n");
817 printf ("Expected s=20, e=2, got s=%s, e=%ld\n", s, (long) e);
818 exit (1);
819 }
820 mpfr_free_str (s);
821 /* try the same example, with input just below or above 13.5 */
822 mpfr_set_prec (x, 1000);
823 mpfr_set_str_binary (x, "1101.1");
824 mpfr_nextabove (x);
825 s = mpfr_get_str (NULL, &e, 7, 2, x, MPFR_RNDN);
826 if (e != 2 || strcmp (s, "20"))
827 {
828 printf ("Error in mpfr_get_str for x=13.5+tiny, base 7\n");
829 printf ("Expected s=20, e=2, got s=%s, e=%ld\n", s, (long) e);
830 exit (1);
831 }
832 mpfr_free_str (s);
833 mpfr_set_str_binary (x, "1101.1");
834 mpfr_nextbelow (x);
835 s = mpfr_get_str (NULL, &e, 7, 2, x, MPFR_RNDN);
836 if (e != 2 || strcmp (s, "16"))
837 {
838 printf ("Error in mpfr_get_str for x=13.5-tiny, base 7\n");
839 printf ("Expected s=16, e=2, got s=%s, e=%ld\n", s, (long) e);
840 exit (1);
841 }
842 mpfr_free_str (s);
843
844 mpfr_set_prec (x, 7);
845 mpfr_set_str_binary (x, "110000.1"); /* 48.5, or (66)_7 + 1/2 */
846 s = mpfr_get_str (NULL, &e, 7, 2, x, MPFR_RNDN);
847 /* we are in the tie case: both surrounding numbers are (66)_7 and
848 (100)_7: since (66)_7 = 48 is even and (100)_7 is odd,
849 we should hase s = "66" and e = 2 */
850 if (e != 2 || strcmp (s, "66"))
851 {
852 printf ("Error in mpfr_get_str for x=48.5, base 7\n");
853 printf ("Expected s=66, e=2, got s=%s, e=%ld\n", s, (long) e);
854 exit (1);
855 }
856 mpfr_free_str (s);
857 /* try the same example, with input just below or above 48.5 */
858 mpfr_set_prec (x, 1000);
859 mpfr_set_str_binary (x, "110000.1");
860 mpfr_nextabove (x);
861 s = mpfr_get_str (NULL, &e, 7, 2, x, MPFR_RNDN);
862 if (e != 3 || strcmp (s, "10"))
863 {
864 printf ("Error in mpfr_get_str for x=48.5+tiny, base 7\n");
865 printf ("Expected s=10, e=3, got s=%s, e=%ld\n", s, (long) e);
866 exit (1);
867 }
868 mpfr_free_str (s);
869 mpfr_set_str_binary (x, "110000.1");
870 mpfr_nextbelow (x);
871 s = mpfr_get_str (NULL, &e, 7, 2, x, MPFR_RNDN);
872 if (e != 2 || strcmp (s, "66"))
873 {
874 printf ("Error in mpfr_get_str for x=48.5-tiny, base 7\n");
875 printf ("Expected s=66, e=2, got s=%s, e=%ld\n", s, (long) e);
876 exit (1);
877 }
878 mpfr_free_str (s);
879
880 mpfr_clear (x);
881 }
882
883 /* bugs found by Alain Delplanque */
884 static void
check_large(void)885 check_large (void)
886 {
887 mpfr_t x;
888 char *s, s1[7];
889 const char xm[] = { '1', '1', '9', '1', '3', '2', '9', '3', '7', '3',
890 '5', '8', '4', '4', '5', '4', '9', '0', '2', '9',
891 '6', '3', '4', '4', '6', '9', '9', '1', '9', '5',
892 '5', '7', '2', '0', '1', '7', '5', '2', '8', '6',
893 '1', '2', '5', '2', '5', '2', '7', '4', '0', '2',
894 '7', '9', '1', '1', '7', '4', '5', '6', '7', '5',
895 '9', '3', '1', '4', '2', '5', '5', '6', '6', '6',
896 '1', '6', '4', '3', '8', '1', '2', '8', '7', '6',
897 '2', '9', '2', '0', '8', '8', '9', '4', '3', '9',
898 '6', '2', '8', '4', '1', '1', '8', '1', '0', '6',
899 '2', '3', '7', '6', '3', '8', '1', '5', '1', '7',
900 '3', '4', '6', '1', '2', '4', '0', '1', '3', '0',
901 '8', '4', '1', '3', '9', '3', '2', '0', '1', '6',
902 '3', '6', '7', '1', '5', '1', '7', '5', '0', '1',
903 '9', '8', '4', '0', '8', '2', '7', '9', '1', '3',
904 '2', '2', '8', '3', '4', '1', '6', '2', '3', '9',
905 '6', '2', '0', '7', '3', '5', '5', '5', '3', '4',
906 '2', '1', '7', '0', '9', '7', '6', '2', '1', '0',
907 '3', '3', '5', '4', '7', '6', '0', '9', '7', '6',
908 '9', '3', '5', '1', '7', '8', '6', '8', '8', '2',
909 '8', '1', '4', '3', '7', '4', '3', '3', '2', '4',
910 '1', '5', '4', '7', '8', '1', '1', '4', '2', '1',
911 '2', '4', '2', '7', '6', '5', '9', '5', '4', '5',
912 '2', '6', '7', '3', '0', '3', '4', '0', '6', '9',
913 '1', '8', '9', '9', '9', '8', '0', '5', '7', '0',
914 '9', '3', '8', '7', '6', '2', '4', '6', '1', '6',
915 '7', '2', '0', '3', '5', '9', '3', '5', '8', '8',
916 '9', '7', '7', '9', '2', '7', '0', '8', '1', '6',
917 '8', '7', '4', '8', '5', '3', '0', '8', '4', '3',
918 '5', '6', '5', '1', '6', '6', '0', '9', '7', '9',
919 '8', '9', '2', '7', '2', '6', '8', '5', '9', '4',
920 '5', '8', '1', '3', '7', '2', '9', '3', '8', '3',
921 '7', '9', '1', '7', '9', '9', '7', '7', '2', '8',
922 '4', '6', '5', '5', '7', '3', '3', '8', '3', '6',
923 '6', '9', '7', '1', '4', '3', '3', '7', '1', '4',
924 '9', '4', '1', '2', '4', '9', '5', '1', '4', '7',
925 '2', '6', '4', '4', '8', '0', '6', '2', '6', '0',
926 '6', '9', '8', '1', '1', '7', '9', '9', '3', '9',
927 '3', '8', '4', '7', '3', '1', '9', '0', '2', '3',
928 '5', '3', '5', '4', '2', '1', '1', '7', '6', '7',
929 '4', '3', '2', '2', '0', '6', '5', '9', '9', '3',
930 '2', '6', '7', '1', '2', '0', '0', '3', '7', '3',
931 '8', '7', '4', '3', '3', '3', '3', '3', '2', '3',
932 '8', '2', '8', '6', '3', '1', '5', '5', '2', '2',
933 '5', '9', '3', '3', '7', '0', '6', '2', '8', '1',
934 '0', '3', '6', '7', '6', '9', '6', '5', '9', '0',
935 '6', '6', '6', '3', '6', '9', '9', '3', '8', '7',
936 '6', '5', '4', '5', '3', '5', '9', '4', '0', '0',
937 '7', '5', '8', '5', '4', '1', '4', '3', '1', '5',
938 '7', '6', '6', '3', '4', '4', '5', '0', '8', '7',
939 '5', '7', '5', '0', '1', '0', '1', '8', '4', '7',
940 '3', '1', '9', '9', '2', '7', '1', '1', '1', '2',
941 '3', '9', '9', '6', '5', '9', '2', '3', '2', '8',
942 '1', '5', '5', '1', '2', '6', '4', '9', '6', '6',
943 '4', '5', '1', '1', '6', '0', '0', '3', '2', '8',
944 '4', '8', '7', '1', '4', '9', '6', '8', '1', '6',
945 '5', '9', '8', '3', '4', '2', '9', '7', '0', '1',
946 '9', '2', '6', '6', '9', '1', '3', '5', '9', '3',
947 '2', '9', '6', '2', '3', '0', '6', '0', '1', '1',
948 '6', '5', '1', '7', '9', '0', '7', '5', '8', '6',
949 '8', '4', '2', '1', '0', '3', '8', '6', '6', '4',
950 '4', '9', '9', '7', '5', '8', '1', '7', '5', '7',
951 '9', '6', '6', '8', '8', '5', '8', '6', '7', '4',
952 '0', '7', '2', '0', '2', '9', '9', '4', '4', '1',
953 '9', '5', '8', '6', '5', '0', '6', '7', '4', '2',
954 '7', '3', '2', '3', '2', '7', '0', '2', '1', '3',
955 '0', '5', '9', '0', '3', '9', '1', '4', '5', '3',
956 '7', '2', '7', '0', '8', '5', '5', '4', '6', '1',
957 '1', '0', '0', '9', '2', '0', '4', '1', '6', '6',
958 '4', '6', '9', '1', '3', '2', '8', '5', '0', '3',
959 '3', '8', '9', '8', '7', '8', '5', '9', '5', '5',
960 '9', '1', '9', '3', '6', '5', '4', '1', '7', '4',
961 '0', '2', '4', '7', '2', '9', '7', '1', '2', '4',
962 '5', '8', '1', '4', '4', '6', '1', '8', '5', '8',
963 '7', '6', '9', '7', '2', '1', '2', '0', '8', '9',
964 '5', '9', '5', '5', '3', '8', '1', '2', '5', '4',
965 '3', '0', '7', '6', '5', '1', '7', '8', '2', '0',
966 '0', '7', '6', '7', '4', '8', '1', '0', '6', '3',
967 '2', '3', '0', '5', '2', '5', '0', '1', '1', '4',
968 '3', '8', '4', '5', '2', '3', '9', '5', '0', '9',
969 '8', '2', '6', '4', '7', '4', '8', '0', '1', '1',
970 '7', '1', '5', '4', '9', '0', '9', '2', '2', '3',
971 '8', '1', '6', '9', '0', '4', '6', '4', '5', '4',
972 '6', '3', '8', '7', '3', '6', '1', '7', '2', '3',
973 '4', '5', '5', '2', '0', '2', '5', '8', '1', '4',
974 '9', '3', '0', '7', '4', '1', '6', '8', '7', '8',
975 '2', '6', '2', '5', '1', '0', '7', '4', '7', '3',
976 '6', '6', '4', '5', '6', '6', '6', '6', '8', '5',
977 '1', '3', '5', '7', '1', '6', '2', '0', '9', '2',
978 '3', '2', '6', '0', '7', '9', '8', '1', '6', '2',
979 '0', '3', '8', '8', '0', '2', '8', '7', '7', '5',
980 '9', '3', '1', '0', '6', '7', '5', '7', '3', '1',
981 '2', '7', '7', '2', '0', '0', '4', '1', '2', '8',
982 '2', '0', '8', '4', '0', '5', '0', '5', '0', '1',
983 '9', '3', '3', '6', '3', '6', '9', '6', '2', '8',
984 '2', '9', '7', '5', '3', '8', '8', '9', '1', '1',
985 '4', '5', '7', '7', '5', '6', '0', '2', '7', '9',
986 '7', '2', '1', '7', '4', '3', '0', '3', '6', '7',
987 '3', '7', '2', '2', '7', '5', '6', '2', '3', '1',
988 '2', '1', '3', '1', '4', '2', '6', '9', '2', '3',
989 '\0' };
990 mpfr_exp_t e;
991
992 mpfr_init2 (x, 3322);
993 mpfr_set_str (x, xm, 10, MPFR_RNDN);
994 mpfr_div_2ui (x, x, 4343, MPFR_RNDN);
995 s = mpfr_get_str (NULL, &e, 10, 1000, x, MPFR_RNDN);
996 if (s[999] != '1') /* s must be 5.04383...689071e-309 */
997 {
998 printf ("Error in check_large: expected '689071', got '%s'\n",
999 s + 994);
1000 exit (1);
1001 }
1002 mpfr_free_str (s);
1003
1004 mpfr_mul_2ui (x, x, 4343, MPFR_RNDN);
1005 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDN);
1006 if (strcmp (s, "12") || (e != 1000))
1007 {
1008 printf ("Error in check_large: expected 0.12e1000\n");
1009 printf ("got %se%d\n", s, (int) e);
1010 exit (1);
1011 }
1012 mpfr_free_str (s);
1013
1014 mpfr_set_nan (x);
1015 mpfr_clear_flags ();
1016 s = mpfr_get_str (NULL, &e, 10, 1000, x, MPFR_RNDN);
1017 if (strcmp (s, "@NaN@"))
1018 {
1019 printf ("Error for NaN (incorrect string)\n");
1020 exit (1);
1021 }
1022 if (__gmpfr_flags != MPFR_FLAGS_NAN)
1023 {
1024 printf ("Error for NaN (incorrect flags)\n");
1025 exit (1);
1026 }
1027 mpfr_free_str (s);
1028
1029 mpfr_get_str (s1, &e, 10, 1000, x, MPFR_RNDN);
1030
1031 mpfr_set_inf (x, 1);
1032 s = mpfr_get_str (NULL, &e, 10, 1000, x, MPFR_RNDN);
1033 if (strcmp (s, "@Inf@"))
1034 {
1035 printf ("Error for Inf\n");
1036 exit (1);
1037 }
1038 mpfr_free_str (s);
1039
1040 mpfr_get_str (s1, &e, 10, 1000, x, MPFR_RNDN);
1041
1042 mpfr_set_inf (x, -1);
1043 s = mpfr_get_str (NULL, &e, 10, 1000, x, MPFR_RNDN);
1044 if (strcmp (s, "-@Inf@"))
1045 {
1046 printf ("Error for -Inf\n");
1047 exit (1);
1048 }
1049 mpfr_free_str (s);
1050
1051 mpfr_get_str (s1, &e, 10, 1000, x, MPFR_RNDN);
1052
1053 mpfr_set_ui (x, 0, MPFR_RNDN);
1054 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDN);
1055 if (e != 0 || strcmp (s, "00"))
1056 {
1057 printf ("Error for 0.0\n");
1058 exit (1);
1059 }
1060 mpfr_free_str (s);
1061 mpfr_get_str (s1, &e, 10, 2, x, MPFR_RNDN);
1062
1063 mpfr_neg (x, x, MPFR_RNDN); /* -0.0 */
1064 s = mpfr_get_str (NULL, &e, 10, 2, x, MPFR_RNDN);
1065 if (e != 0 || strcmp (s, "-00"))
1066 {
1067 printf ("Error for -0.0\ngot %se%d\n", s, (int) e);
1068 exit (1);
1069 }
1070 mpfr_free_str (s);
1071 mpfr_get_str (s1, &e, 10, 2, x, MPFR_RNDN);
1072
1073 mpfr_clear (x);
1074 }
1075
1076 #define MAX_DIGITS 100
1077
1078 static void
check_special(int b,mpfr_prec_t p)1079 check_special (int b, mpfr_prec_t p)
1080 {
1081 mpfr_t x;
1082 int i, j;
1083 char s[MAX_DIGITS + 2], s2[MAX_DIGITS + 2], c;
1084 mpfr_exp_t e;
1085 int r;
1086 size_t m;
1087
1088 mpfr_init2 (x, p);
1089
1090 /* check for invalid base */
1091 if (mpfr_get_str (s, &e, 1, 10, x, MPFR_RNDN) != NULL)
1092 {
1093 printf ("Error: mpfr_get_str should not accept base = 1\n");
1094 exit (1);
1095 }
1096 if (mpfr_get_str (s, &e, 63, 10, x, MPFR_RNDN) != NULL)
1097 {
1098 printf ("Error: mpfr_get_str should not accept base = 63\n");
1099 exit (1);
1100 }
1101
1102 s2[0] = '1';
1103 for (i = 1; i < MAX_DIGITS + 2; i++)
1104 s2[i] = '0';
1105
1106 mpfr_set_ui (x, 1, MPFR_RNDN);
1107 for (i = 1; i < MAX_DIGITS && mpfr_mul_ui (x, x, b, MPFR_RNDN) == 0; i++)
1108 {
1109 /* x = b^i (exact) */
1110 RND_LOOP (r)
1111 for (m = i < 3 ? 2 : i-1 ; (int) m <= i+1 ; m++)
1112 {
1113 mpfr_get_str (s, &e, b, m, x, (mpfr_rnd_t) r);
1114 /* s should be 1 followed by (m-1) zeros, and e should be i+1 */
1115 if ((e != i+1) || strncmp (s, s2, m) != 0)
1116 {
1117 printf ("Error in mpfr_get_str for %d^%d\n", b, i);
1118 exit (1);
1119 }
1120 }
1121 if (mpfr_sub_ui (x, x, 1, MPFR_RNDN) != 0)
1122 break;
1123 /* now x = b^i-1 (exact) */
1124 RND_LOOP (r)
1125 if (i >= 2)
1126 {
1127 mpfr_get_str (s, &e, b, i, x, (mpfr_rnd_t) r);
1128 /* should be i times (b-1) */
1129 c = (b <= 10) ? '0' + b - 1 : 'a' + (b - 11);
1130 for (j=0; (j < i) && (s[j] == c); j++);
1131 if ((j < i) || (e != i))
1132 {
1133 printf ("Error in mpfr_get_str for %d^%d-1\n", b, i);
1134 printf ("got 0.%s*2^%d\n", s, (int) e);
1135 exit (1);
1136 }
1137 }
1138 if (i >= 3)
1139 {
1140 mpfr_get_str (s, &e, b, i - 1, x, MPFR_RNDU);
1141 /* should be b^i */
1142 if ((e != i+1) || strncmp (s, s2, i - 1) != 0)
1143 {
1144 printf ("Error in mpfr_get_str for %d^%d-1\n", b, i);
1145 printf ("got 0.%s*2^%d\n", s, (int) e);
1146 exit (1);
1147 }
1148 }
1149
1150 mpfr_add_ui (x, x, 1, MPFR_RNDN);
1151 }
1152 mpfr_clear (x);
1153 }
1154
1155 static void
check_bug_base2k(void)1156 check_bug_base2k (void)
1157 {
1158 /*
1159 * -2.63b22b55697e800000000000@130
1160 * +-0.1001100011101100100010101101010101011010010111111010000000000000000000000000+00000000000000000000001E522
1161 */
1162 mpfr_t xx, yy, zz;
1163 char *s;
1164 mpfr_exp_t e;
1165
1166 mpfr_init2 (xx, 107);
1167 mpfr_init2 (yy, 79);
1168 mpfr_init2 (zz, 99);
1169
1170 mpfr_set_str (xx, "-1.90e8c3e525d7c0000000000000@-18", 16, MPFR_RNDN);
1171 mpfr_set_str (yy, "-2.63b22b55697e8000000@130", 16, MPFR_RNDN);
1172 mpfr_add (zz, xx, yy, MPFR_RNDD);
1173 s = mpfr_get_str (NULL, &e, 16, 0, zz, MPFR_RNDN);
1174 if (strcmp (s, "-263b22b55697e8000000000008"))
1175 {
1176 printf ("Error for get_str base 16\n"
1177 "Got %s expected -263b22b55697e8000000000008\n", s);
1178 exit (1);
1179 }
1180 mpfr_free_str (s);
1181 mpfr_clears (xx, yy, zz, (mpfr_ptr) 0);
1182 }
1183
1184 static void
check_reduced_exprange(void)1185 check_reduced_exprange (void)
1186 {
1187 mpfr_t x;
1188 char *s;
1189 mpfr_exp_t emax, e;
1190
1191 emax = mpfr_get_emax ();
1192 mpfr_init2 (x, 8);
1193 mpfr_set_str (x, "0.11111111E0", 2, MPFR_RNDN);
1194 set_emax (0);
1195 s = mpfr_get_str (NULL, &e, 16, 0, x, MPFR_RNDN);
1196 set_emax (emax);
1197 if (strcmp (s, "ff0"))
1198 {
1199 printf ("Error for mpfr_get_str on 0.11111111E0 in base 16:\n"
1200 "Got \"%s\" instead of \"ff0\".\n", s);
1201 exit (1);
1202 }
1203 mpfr_free_str (s);
1204 mpfr_clear (x);
1205 }
1206
1207 static void
check_inex(void)1208 check_inex (void)
1209 {
1210 mpfr_t x;
1211 int i;
1212
1213 mpfr_init2 (x, 8);
1214 mpfr_set_str (x, "0.11111111E-17", 2, MPFR_RNDN);
1215 for (i = 1; i <= 25; i++)
1216 {
1217 char *s[2];
1218 int r, inex = 0;
1219
1220 RND_LOOP (r)
1221 {
1222 mpfr_exp_t e;
1223 mpfr_flags_t flags;
1224
1225 mpfr_clear_flags ();
1226 s[r != 0] = mpfr_get_str (NULL, &e, 10, i, x, (mpfr_rnd_t) r);
1227 MPFR_ASSERTN (e == -5);
1228 flags = __gmpfr_flags;
1229 if ((i >= 20) ^ (! mpfr_inexflag_p ()))
1230 {
1231 printf ("Error in check_inex on i=%d and %s\n",
1232 i, mpfr_print_rnd_mode ((mpfr_rnd_t) r));
1233 printf ("Got %s\n", s[r != 0]);
1234 printf ("Flags:");
1235 flags_out (flags);
1236 exit (1);
1237 }
1238 if (r != 0)
1239 {
1240 inex |= strcmp (s[0], s[1]) != 0;
1241 mpfr_free_str (s[1]);
1242 }
1243 }
1244
1245 MPFR_ASSERTN ((i >= 20) ^ inex);
1246 mpfr_free_str (s[0]);
1247 }
1248 mpfr_clear (x);
1249 }
1250
1251 static void
check_negative_base(void)1252 check_negative_base (void)
1253 {
1254 mpfr_t f;
1255 mpfr_exp_t e;
1256 char *s, s2[16] = "7B000000000000", s3[16] = "74000000000000";
1257
1258 mpfr_init_set_ui (f, 123, MPFR_RNDN);
1259 s = mpfr_get_str (0, &e, -16, 0, f, MPFR_RNDN);
1260 MPFR_ASSERTN(strcmp (s, s2) == 0);
1261 mpfr_free_str (s);
1262 s = mpfr_get_str (0, &e, -17, 0, f, MPFR_RNDN);
1263 MPFR_ASSERTN(strcmp (s, s3) == 0);
1264 mpfr_free_str (s);
1265 mpfr_clear (f);
1266 }
1267
1268 #define ITER 1000
1269
1270 static void
coverage(void)1271 coverage (void)
1272 {
1273 mpfr_t x;
1274 char s[42];
1275 mpfr_exp_t e;
1276 int b = 3;
1277 size_t m = 40;
1278
1279 mpfr_init2 (x, 128);
1280
1281 /* exercise corner case in mpfr_get_str_aux: exact case (e < 0), where r
1282 rounds to a power of 2, and f is a multiple of GMP_NUMB_BITS */
1283 mpfr_set_ui_2exp (x, 1, 64, MPFR_RNDU);
1284 mpfr_nextbelow (x);
1285 /* x = 2^64 - 2^(-64) */
1286 mpfr_get_str (s, &e, b, m, x, MPFR_RNDU);
1287 /* s is the base-3 string for 6148914691236517206 (in base 10) */
1288 MPFR_ASSERTN(strcmp (s, "1111222002212212010121102012021021021200") == 0);
1289 MPFR_ASSERTN(e == 41);
1290
1291 /* exercise corner case in mpfr_get_str: input is m=0, then it is changed
1292 to m=1 */
1293 mpfr_set_prec (x, 1);
1294 mpfr_set_ui (x, 1, MPFR_RNDN);
1295 mpfr_get_str (s, &e, 2, 0, x, MPFR_RNDN);
1296 MPFR_ASSERTN(strcmp (s, "1") == 0);
1297 MPFR_ASSERTN(e == 1);
1298 mpfr_get_str (s, &e, 2, 1, x, MPFR_RNDN);
1299 MPFR_ASSERTN(strcmp (s, "1") == 0);
1300 MPFR_ASSERTN(e == 1);
1301
1302 /* exercise corner case in mpfr_get_str: case m < g, exact <> 0,
1303 nx > 2 * n, and low nx-2n limbs from xp not identically zero */
1304 mpfr_set_prec (x, 129);
1305 mpfr_set_str_binary (x, "0.100100111110110111100010100011011111101010110000011001000111111101100110101110110000110011E8");
1306 mpfr_nextabove (x);
1307 mpfr_get_str (s, &e, 10, 2, x, MPFR_RNDZ);
1308 MPFR_ASSERTN(strcmp (s, "14") == 0);
1309 MPFR_ASSERTN(e == 3);
1310
1311 mpfr_clear (x);
1312 }
1313
1314 static void
test_ndigits_aux(int b,mpfr_prec_t p,size_t expected_m)1315 test_ndigits_aux (int b, mpfr_prec_t p, size_t expected_m)
1316 {
1317 size_t m;
1318 mpfr_exp_t old_emin, old_emax, e[] = { MPFR_EMIN_MIN, 0, MPFR_EMAX_MAX };
1319 mpfr_flags_t flags;
1320 int i;
1321
1322 old_emin = mpfr_get_emin ();
1323 old_emax = mpfr_get_emax ();
1324
1325 i = randlimb () % (numberof (e) + 1);
1326 if (i < numberof (e))
1327 {
1328 set_emin (e[i]);
1329 set_emax (e[i]);
1330 }
1331
1332 __gmpfr_flags = flags = randlimb () & MPFR_FLAGS_ALL;
1333 m = mpfr_get_str_ndigits (b, p);
1334 MPFR_ASSERTN (m == expected_m);
1335 MPFR_ASSERTN (__gmpfr_flags == flags);
1336
1337 set_emin (old_emin);
1338 set_emax (old_emax);
1339 }
1340
1341 /* test of mpfr_get_str_ndigits */
1342 static void
test_ndigits(void)1343 test_ndigits (void)
1344 {
1345 mpfr_prec_t p;
1346
1347 /* for b=2, we have 1 + ceil((p-1)*log(2)/log(b)) = p */
1348 for (p = MPFR_PREC_MIN; p <= 1024; p++)
1349 test_ndigits_aux (2, p, p);
1350
1351 /* for b=4, we have 1 + ceil((p-1)*log(2)/log(b)) = 1 + ceil((p-1)/2)
1352 = 1 + floor(p/2) */
1353 for (p = MPFR_PREC_MIN; p <= 1024; p++)
1354 test_ndigits_aux (4, p, 1 + (p / 2));
1355
1356 /* for b=8, we have 1 + ceil((p-1)*log(2)/log(b)) = 1 + ceil((p-1)/3)
1357 = 1 + floor((p+1)/3) */
1358 for (p = MPFR_PREC_MIN; p <= 1024; p++)
1359 test_ndigits_aux (8, p, 1 + ((p + 1) / 3));
1360
1361 /* for b=16, we have 1 + ceil((p-1)*log(2)/log(b)) = 1 + ceil((p-1)/4)
1362 = 1 + floor((p+2)/4) */
1363 for (p = MPFR_PREC_MIN; p <= 1024; p++)
1364 test_ndigits_aux (16, p, 1 + ((p + 2) / 4));
1365
1366 /* for b=32, we have 1 + ceil((p-1)*log(2)/log(b)) = 1 + ceil((p-1)/5)
1367 = 1 + floor((p+3)/5) */
1368 for (p = MPFR_PREC_MIN; p <= 1024; p++)
1369 test_ndigits_aux (32, p, 1 + ((p + 3) / 5));
1370
1371 /* error < 1e-3 */
1372 test_ndigits_aux (57, 35, 8);
1373
1374 /* error < 1e-4 */
1375 test_ndigits_aux (31, 649, 133);
1376
1377 /* error < 1e-5 */
1378 test_ndigits_aux (43, 5041, 931);
1379
1380 /* error < 1e-6 */
1381 test_ndigits_aux (41, 17771, 3319);
1382
1383 /* 20th convergent of log(2)/log(3) */
1384 test_ndigits_aux (3, 630138897, 397573381);
1385
1386 #if MPFR_PREC_BITS >= 64
1387 /* 21st convergent of log(2)/log(3) */
1388 test_ndigits_aux (3, 9809721694, 6189245292);
1389
1390 /* 22nd convergent of log(2)/log(3) */
1391 test_ndigits_aux (3, 10439860591, 6586818672);
1392
1393 /* 23rd convergent of log(2)/log(3) */
1394 test_ndigits_aux (3, 103768467013, 65470613322);
1395
1396 /* 24th convergent of log(2)/log(3) */
1397 test_ndigits_aux (3, 217976794617, 137528045314);
1398
1399 test_ndigits_aux (3, 1193652440098, 753110839882);
1400
1401 test_ndigits_aux (3, 683381996816440, 431166034846569);
1402
1403 test_ndigits_aux (7, 186564318007, 66455550933);
1404 #endif
1405 }
1406
1407 /* check corner cases: radix-b number near from b^e converted to mpfr_t
1408 and then back to radix b */
1409 static void
check_corner(void)1410 check_corner (void)
1411 {
1412 int b; /* external radix */
1413 mpfr_exp_t e; /* external exponent */
1414 mpfr_prec_t oprec; /* external precision */
1415 mpfr_prec_t iprec; /* internal precision */
1416 #define MAX_OPREC 100
1417 char *s, *t;
1418 int i, ret;
1419 mpfr_exp_t f;
1420
1421 for (b = 2; b <= 62; b++)
1422 for (e = -100; e <= 100; e++)
1423 for (iprec = MPFR_PREC_MIN; iprec <= 100; iprec ++)
1424 {
1425 mpfr_t x, y;
1426 oprec = mpfr_get_str_ndigits (b, iprec);
1427 s = (char *) tests_allocate (oprec + 6);
1428 /* oprec characters for the significand, 1 for the '@' sign,
1429 at most 4 for the exponent (-100), and 1 for the terminating
1430 '\0'. */
1431 t = (char *) tests_allocate (oprec + 6);
1432 mpfr_init2 (x, iprec);
1433 mpfr_init2 (y, iprec);
1434 /* set s to 1000...000Ee */
1435 s[0] = '1';
1436 for (i = 1; i < oprec; i++)
1437 s[i] = '0';
1438 s[oprec] = '@';
1439 ret = sprintf (s + oprec + 1, "%ld", (long) e);
1440 MPFR_ASSERTN(ret <= 4);
1441 /* sprintf prints the terminating null byte */
1442 ret = mpfr_set_str (x, s, b, MPFR_RNDN);
1443 MPFR_ASSERTN(ret == 0);
1444 mpfr_get_str (t, &f, b, 0, x, MPFR_RNDN);
1445 MPFR_ASSERTN(strlen (t) == oprec);
1446 t[oprec] = '@';
1447 ret = sprintf (t + oprec + 1, "%ld", (long) (f - oprec));
1448 MPFR_ASSERTN(ret <= 4);
1449 ret = mpfr_set_str (y, t, b, MPFR_RNDN);
1450 MPFR_ASSERTN(ret == 0);
1451 if (!mpfr_equal_p (x, y))
1452 {
1453 printf ("mpfr_set_str o mpfr_get_str <> Id for b=%d\n", b);
1454 printf ("x="); mpfr_dump (x);
1455 t[oprec] = '\0';
1456 printf ("mpfr_get_str converted to 0.%s@%ld\n", t, (long) f);
1457 printf ("mpfr_set_str converted to:\n");
1458 printf ("y="); mpfr_dump (y);
1459 exit (1);
1460 }
1461 mpfr_clear (x);
1462 mpfr_clear (y);
1463 tests_free (s, oprec + 6);
1464 tests_free (t, oprec + 6);
1465 }
1466 }
1467
1468 int
main(int argc,char * argv[])1469 main (int argc, char *argv[])
1470 {
1471 int b;
1472 mpfr_t x;
1473 mpfr_rnd_t r;
1474 char s[MAX_DIGITS + 2];
1475 mpfr_exp_t e, f;
1476 size_t m;
1477 mpfr_prec_t p;
1478 int i;
1479
1480 tests_start_mpfr ();
1481
1482 check_corner ();
1483 test_ndigits ();
1484 coverage ();
1485 check_small ();
1486
1487 check_special (2, 2);
1488 for (i = 0; i < ITER; i++)
1489 {
1490 p = 2 + (randlimb () % (MAX_DIGITS - 1));
1491 b = 2 + (randlimb () % 35);
1492 check_special (b, p);
1493 }
1494
1495 mpfr_init2 (x, MAX_DIGITS);
1496 for (i = 0; i < ITER; i++)
1497 {
1498 m = 2 + (randlimb () % (MAX_DIGITS - 1));
1499 mpfr_urandomb (x, RANDS);
1500 e = (mpfr_exp_t) (randlimb () % 21) - 10;
1501 if (!MPFR_IS_ZERO(x))
1502 mpfr_set_exp (x, (e == -10) ? mpfr_get_emin () :
1503 ((e == 10) ? mpfr_get_emax () : e));
1504 b = 2 + (randlimb () % 35);
1505 r = RND_RAND ();
1506 mpfr_get_str (s, &f, b, m, x, r);
1507 }
1508 mpfr_clear (x);
1509
1510 check_large ();
1511 check3 ("4.059650008e-83", MPFR_RNDN, "40597");
1512 check3 ("-6.606499965302424244461355e233", MPFR_RNDN, "-66065");
1513 check3 ("-7.4", MPFR_RNDN, "-74000");
1514 check3 ("0.997", MPFR_RNDN, "99700");
1515 check3 ("-4.53063926135729747564e-308", MPFR_RNDN, "-45306");
1516 check3 ("2.14478198760196000000e+16", MPFR_RNDN, "21448");
1517 check3 ("7.02293374921793516813e-84", MPFR_RNDN, "70229");
1518
1519 check3 ("-6.7274500420134077e-87", MPFR_RNDN, "-67275");
1520 check3 ("-6.7274500420134077e-87", MPFR_RNDZ, "-67274");
1521 check3 ("-6.7274500420134077e-87", MPFR_RNDU, "-67274");
1522 check3 ("-6.7274500420134077e-87", MPFR_RNDD, "-67275");
1523 check3 ("-6.7274500420134077e-87", MPFR_RNDA, "-67275");
1524
1525 check3 ("6.7274500420134077e-87", MPFR_RNDN, "67275");
1526 check3 ("6.7274500420134077e-87", MPFR_RNDZ, "67274");
1527 check3 ("6.7274500420134077e-87", MPFR_RNDU, "67275");
1528 check3 ("6.7274500420134077e-87", MPFR_RNDD, "67274");
1529 check3 ("6.7274500420134077e-87", MPFR_RNDA, "67275");
1530
1531 check_bug_base2k ();
1532 check_reduced_exprange ();
1533 check_inex ();
1534 check_negative_base ();
1535
1536 tests_end_mpfr ();
1537 return 0;
1538 }
1539