1 /* Test file for mpfr_set_decimal128 and mpfr_get_decimal128. 2 3 Copyright 2018-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 /* Needed due to the test on MPFR_WANT_DECIMAL_FLOATS */ 24 #ifdef HAVE_CONFIG_H 25 # include "config.h" 26 #endif 27 28 #ifdef MPFR_WANT_DECIMAL_FLOATS 29 30 #include "mpfr-test.h" 31 32 #ifndef DEC128_MAX 33 # define DEC128_MAX 9.999999999999999999999999999999999E6144dl 34 #endif 35 36 static void 37 print_decimal128 (_Decimal128 d) 38 { 39 if (DOUBLE_ISNAN (d)) 40 printf ("NaN"); 41 else if (d > DEC128_MAX) 42 printf ("Inf"); 43 else if (d < -DEC128_MAX) 44 printf ("-Inf"); 45 else if (d == 0) 46 { 47 printf ("%.1f", (double) d); 48 } 49 else /* regular number */ 50 { 51 long e = 0; 52 while (d < 1.dl) 53 { 54 d *= 10.dl; 55 e --; 56 } 57 /* now d >= 1 */ 58 while (d > 10.dl) 59 { 60 d /= 10.dl; 61 e ++; 62 } 63 /* now 1 <= d < 10 */ 64 printf ("%.33LfE%ld", (long double) d, e); 65 } 66 printf ("\n"); 67 } 68 69 #define PRINT_ERR_MISC(V) \ 70 do \ 71 { \ 72 printf ("Error in check_misc for %s.\n", V); \ 73 printf (" mpfr_get_decimal128() returned: "); \ 74 print_decimal128 (d); \ 75 printf (" mpfr_set_decimal128() set x to: "); \ 76 mpfr_out_str (stdout, 10, 0, x, MPFR_RNDN); \ 77 printf (" approx.\n = "); \ 78 mpfr_dump (x); \ 79 exit (1); \ 80 } \ 81 while (0) 82 83 static void 84 test_set (void) 85 { 86 long v[] = { 1, -1, 2147483647, -2147483647 }; 87 mpfr_t x; 88 mpfr_flags_t flags; 89 int i, inex; 90 91 mpfr_init2 (x, 53); 92 for (i = 0; i < numberof (v); i++) 93 { 94 mpfr_clear_flags (); 95 inex = mpfr_set_decimal128 (x, (_Decimal128) v[i], MPFR_RNDN); 96 flags = __gmpfr_flags; 97 if (mpfr_cmp_si (x, v[i]) != 0 || inex != 0 || flags != 0) 98 { 99 printf ("Error in test_set for i=%d\n", i); 100 printf ("Expected %ld\n with inex = 0 and flags =", v[i]); 101 flags_out (0); 102 printf ("Got "); 103 mpfr_dump (x); 104 printf (" with inex = %d and flags =", inex); 105 flags_out (flags); 106 exit (1); 107 } 108 } 109 mpfr_clear (x); 110 } 111 112 static void 113 powers_of_10 (void) 114 { 115 mpfr_t x1, x2; 116 _Decimal128 d[2]; 117 int i, rnd; 118 unsigned int neg; 119 120 mpfr_inits2 (200, x1, x2, (mpfr_ptr) 0); 121 for (i = 0, d[0] = 1, d[1] = 1; i < 150; i++, d[0] *= 10, d[1] /= 10) 122 for (neg = 0; neg <= 3; neg++) 123 RND_LOOP_NO_RNDF (rnd) 124 { 125 int inex1, inex2; 126 mpfr_flags_t flags1, flags2; 127 mpfr_rnd_t rx1; 128 _Decimal128 dd; 129 130 inex1 = mpfr_set_si (x1, (neg >> 1) ? -i : i, MPFR_RNDN); 131 MPFR_ASSERTN (inex1 == 0); 132 133 rx1 = (neg & 1) ? 134 MPFR_INVERT_RND ((mpfr_rnd_t) rnd) : (mpfr_rnd_t) rnd; 135 mpfr_clear_flags (); 136 inex1 = mpfr_exp10 (x1, x1, rx1); 137 flags1 = __gmpfr_flags; 138 139 dd = d[neg >> 1]; 140 141 if (neg & 1) 142 { 143 MPFR_SET_NEG (x1); 144 inex1 = -inex1; 145 dd = -dd; 146 } 147 148 mpfr_clear_flags (); 149 inex2 = mpfr_set_decimal128 (x2, dd, (mpfr_rnd_t) rnd); 150 flags2 = __gmpfr_flags; 151 152 if (!(mpfr_equal_p (x1, x2) && 153 SAME_SIGN (inex1, inex2) && 154 flags1 == flags2)) 155 { 156 printf ("Error in powers_of_10 for i=%d, neg=%d, %s\n", 157 i, neg, mpfr_print_rnd_mode ((mpfr_rnd_t) rnd)); 158 printf ("Expected "); 159 mpfr_dump (x1); 160 printf ("with inex = %d and flags =", inex1); 161 flags_out (flags1); 162 printf ("Got "); 163 mpfr_dump (x2); 164 printf ("with inex = %d and flags =", inex2); 165 flags_out (flags2); 166 exit (1); 167 } 168 } 169 mpfr_clears (x1, x2, (mpfr_ptr) 0); 170 } 171 172 static void 173 check_misc (void) 174 { 175 mpfr_t x, y; 176 _Decimal128 d; 177 178 mpfr_init2 (x, 123); 179 mpfr_init2 (y, 123); 180 181 #if !defined(MPFR_ERRDIVZERO) 182 mpfr_set_nan (x); 183 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 184 mpfr_set_ui (x, 1, MPFR_RNDZ); 185 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 186 MPFR_ASSERTN (mpfr_nan_p (x)); 187 188 mpfr_set_inf (x, 1); 189 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 190 mpfr_set_ui (x, 1, MPFR_RNDZ); 191 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 192 if (! mpfr_inf_p (x) || MPFR_IS_NEG (x)) 193 PRINT_ERR_MISC ("+Inf"); 194 195 mpfr_set_inf (x, -1); 196 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 197 mpfr_set_ui (x, 1, MPFR_RNDZ); 198 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 199 if (! mpfr_inf_p (x) || MPFR_IS_POS (x)) 200 PRINT_ERR_MISC ("-Inf"); 201 #endif 202 203 mpfr_set_ui (x, 0, MPFR_RNDZ); 204 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 205 mpfr_set_ui (x, 1, MPFR_RNDZ); 206 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 207 if (MPFR_NOTZERO (x) || MPFR_IS_NEG (x)) 208 PRINT_ERR_MISC ("+0"); 209 210 mpfr_set_ui (x, 0, MPFR_RNDZ); 211 mpfr_neg (x, x, MPFR_RNDZ); 212 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 213 mpfr_set_ui (x, 1, MPFR_RNDZ); 214 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 215 if (MPFR_NOTZERO (x) || MPFR_IS_POS (x)) 216 PRINT_ERR_MISC ("-0"); 217 218 mpfr_set_ui (x, 1, MPFR_RNDZ); 219 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 220 mpfr_set_ui (x, 0, MPFR_RNDZ); 221 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 222 if (mpfr_cmp_ui (x, 1) != 0) 223 PRINT_ERR_MISC ("+1"); 224 225 mpfr_set_si (x, -1, MPFR_RNDZ); 226 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 227 mpfr_set_ui (x, 0, MPFR_RNDZ); 228 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 229 if (mpfr_cmp_si (x, -1) != 0) 230 PRINT_ERR_MISC ("-1"); 231 232 mpfr_set_ui (x, 2, MPFR_RNDZ); 233 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 234 mpfr_set_ui (x, 0, MPFR_RNDZ); 235 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 236 if (mpfr_cmp_ui (x, 2) != 0) 237 PRINT_ERR_MISC ("2"); 238 239 mpfr_set_ui (x, 99, MPFR_RNDZ); 240 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 241 mpfr_set_ui (x, 0, MPFR_RNDZ); 242 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 243 if (mpfr_cmp_ui (x, 99) != 0) 244 PRINT_ERR_MISC ("99"); 245 246 mpfr_set_str (x, "9999999999999999999999999999999999", 10, MPFR_RNDZ); 247 mpfr_set (y, x, MPFR_RNDZ); 248 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 249 mpfr_set_ui (x, 0, MPFR_RNDZ); 250 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 251 if (! mpfr_equal_p (x, y)) 252 PRINT_ERR_MISC ("9999999999999999999999999999999999"); 253 254 /* smallest normal number */ 255 mpfr_set_str (x, "1E-6143", 10, MPFR_RNDU); 256 mpfr_set (y, x, MPFR_RNDZ); 257 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 258 mpfr_set_ui (x, 0, MPFR_RNDZ); 259 mpfr_set_decimal128 (x, d, MPFR_RNDU); 260 if (! mpfr_equal_p (x, y)) 261 PRINT_ERR_MISC ("1E-6143"); 262 263 /* smallest subnormal number */ 264 mpfr_set_str (x, "1E-6176", 10, MPFR_RNDU); 265 mpfr_set (y, x, MPFR_RNDZ); 266 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 267 mpfr_set_ui (x, 0, MPFR_RNDZ); 268 mpfr_set_decimal128 (x, d, MPFR_RNDU); 269 if (! mpfr_equal_p (x, y)) 270 PRINT_ERR_MISC ("1E-6176"); 271 272 /* exercise case e < -20517, i.e., x < 0.5*2^(-20517) */ 273 mpfr_set_ui_2exp (x, 1, -20518, MPFR_RNDN); 274 mpfr_nextbelow (x); 275 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 276 /* d should equal +0 */ 277 mpfr_set_decimal128 (x, d, MPFR_RNDN); 278 MPFR_ASSERTN(mpfr_zero_p (x) && mpfr_signbit (x) == 0); 279 /* check RNDA */ 280 mpfr_set_ui_2exp (x, 1, -20518, MPFR_RNDN); 281 mpfr_nextbelow (x); 282 d = mpfr_get_decimal128 (x, MPFR_RNDA); 283 /* d should equal 1E-6176 */ 284 mpfr_set_decimal128 (x, d, MPFR_RNDN); 285 mpfr_set_str (y, "1E-6176", 10, MPFR_RNDN); 286 MPFR_ASSERTN(mpfr_equal_p (x, y)); 287 /* check negative number */ 288 mpfr_set_ui_2exp (x, 1, -20518, MPFR_RNDN); 289 mpfr_nextbelow (x); 290 mpfr_neg (x, x, MPFR_RNDN); 291 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 292 /* d should equal -0 */ 293 mpfr_set_decimal128 (x, d, MPFR_RNDN); 294 MPFR_ASSERTN(mpfr_zero_p (x) && mpfr_signbit (x) == 1); 295 296 /* exercise case e10 < -6175 */ 297 mpfr_set_ui_2exp (x, 1, -20517, MPFR_RNDN); 298 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 299 mpfr_set_decimal128 (x, d, MPFR_RNDN); 300 MPFR_ASSERTN(mpfr_zero_p (x) && mpfr_signbit (x) == 0); 301 mpfr_set_ui_2exp (x, 1, -20517, MPFR_RNDN); 302 d = mpfr_get_decimal128 (x, MPFR_RNDU); 303 mpfr_set_str (y, "1E-6176", 10, MPFR_RNDN); 304 mpfr_set_decimal128 (x, d, MPFR_RNDN); 305 MPFR_ASSERTN(mpfr_equal_p (x, y)); 306 mpfr_set_ui_2exp (x, 1, -20517, MPFR_RNDN); 307 /* 2^(-20517) = 5.85570193228610e-6177 thus should be rounded to 1E-6176 */ 308 d = mpfr_get_decimal128 (x, MPFR_RNDN); 309 mpfr_set_str (y, "1E-6176", 10, MPFR_RNDN); 310 mpfr_set_decimal128 (x, d, MPFR_RNDN); 311 MPFR_ASSERTN(mpfr_equal_p (x, y)); 312 313 /* subnormal number with exponent change when we round back 314 from 34 digits to 1 digit */ 315 mpfr_set_str (x, "9.9E-6176", 10, MPFR_RNDN); 316 d = mpfr_get_decimal128 (x, MPFR_RNDU); /* should be 1E-6175 */ 317 mpfr_set_ui (x, 0, MPFR_RNDZ); 318 mpfr_set_decimal128 (x, d, MPFR_RNDU); 319 mpfr_set_str (y, "1E-6175", 10, MPFR_RNDN); 320 if (! mpfr_equal_p (x, y)) 321 PRINT_ERR_MISC ("9.9E-6176"); 322 323 /* largest number */ 324 mpfr_set_str (x, "9.999999999999999999999999999999999E6144", 10, MPFR_RNDZ); 325 mpfr_set (y, x, MPFR_RNDZ); 326 d = mpfr_get_decimal128 (x, MPFR_RNDU); 327 if (d == DEC128_MAX) 328 { 329 mpfr_set_ui (x, 0, MPFR_RNDZ); 330 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 331 if (! mpfr_equal_p (x, y)) 332 PRINT_ERR_MISC ("DEC128_MAX"); 333 } 334 else 335 { 336 printf ("Error in check_misc for DEC128_MAX.\n"); 337 printf (" mpfr_get_decimal128() returned: "); 338 print_decimal128 (d); 339 exit (1); 340 } 341 342 mpfr_set_str (x, "-9.999999999999999999999999999999999E6144", 10, MPFR_RNDZ); 343 mpfr_set (y, x, MPFR_RNDZ); 344 d = mpfr_get_decimal128 (x, MPFR_RNDA); 345 if (d == -DEC128_MAX) 346 { 347 mpfr_set_ui (x, 0, MPFR_RNDZ); 348 mpfr_set_decimal128 (x, d, MPFR_RNDZ); 349 if (! mpfr_equal_p (x, y)) 350 PRINT_ERR_MISC ("-DEC128_MAX"); 351 } 352 else 353 { 354 printf ("Error in check_misc for -DEC128_MAX.\n"); 355 printf (" mpfr_get_decimal128() returned: "); 356 print_decimal128 (d); 357 exit (1); 358 } 359 360 /* exercise |x| > DEC128_MAX */ 361 mpfr_set_str (x, "10E6144", 10, MPFR_RNDU); 362 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 363 MPFR_ASSERTN(d == DEC128_MAX); 364 mpfr_set_str (x, "-10E6144", 10, MPFR_RNDU); 365 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 366 MPFR_ASSERTN(d == -DEC128_MAX); 367 368 mpfr_set_prec (x, 53); 369 mpfr_set_prec (y, 53); 370 371 /* largest number */ 372 mpfr_set_str (x, "9.999999999999999999999999999999999E6144", 10, MPFR_RNDZ); 373 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 374 mpfr_set_decimal128 (y, d, MPFR_RNDU); 375 if (! mpfr_equal_p (x, y)) 376 PRINT_ERR_MISC ("DEC128_MAX (2)"); 377 378 /* since 1+ceil(109*log(2)/log(10)) = 34, the 109-bit value x, when 379 converted to a 34-digit decimal d, gives back x when converted back to 380 binary */ 381 mpfr_set_prec (x, 109); 382 mpfr_set_prec (y, 109); 383 mpfr_set_str (x, "1E1793", 10, MPFR_RNDN); 384 d = mpfr_get_decimal128 (x, MPFR_RNDN); 385 mpfr_set_ui (x, 0, MPFR_RNDZ); 386 mpfr_set_decimal128 (x, d, MPFR_RNDN); 387 mpfr_set_str (y, "1E1793", 10, MPFR_RNDN); 388 if (! mpfr_equal_p (x, y)) 389 PRINT_ERR_MISC ("1E1793"); 390 391 mpfr_set_str (x, "2E4095", 10, MPFR_RNDN); 392 d = mpfr_get_decimal128 (x, MPFR_RNDN); 393 mpfr_set_ui (x, 0, MPFR_RNDZ); 394 mpfr_set_decimal128 (x, d, MPFR_RNDN); 395 mpfr_set_str (y, "2E4095", 10, MPFR_RNDN); 396 if (! mpfr_equal_p (x, y)) 397 PRINT_ERR_MISC ("2E4095"); 398 399 mpfr_set_str (x, "2E-4096", 10, MPFR_RNDN); 400 d = mpfr_get_decimal128 (x, MPFR_RNDN); 401 mpfr_set_ui (x, 0, MPFR_RNDZ); 402 mpfr_set_decimal128 (x, d, MPFR_RNDN); 403 mpfr_set_str (y, "2E-4096", 10, MPFR_RNDN); 404 if (! mpfr_equal_p (x, y)) 405 PRINT_ERR_MISC ("2E-4096"); 406 407 mpfr_set_str (x, "2E-6110", 10, MPFR_RNDN); 408 d = mpfr_get_decimal128 (x, MPFR_RNDN); 409 mpfr_set_ui (x, 0, MPFR_RNDZ); 410 mpfr_set_decimal128 (x, d, MPFR_RNDN); 411 mpfr_set_str (y, "2E-6110", 10, MPFR_RNDN); 412 if (! mpfr_equal_p (x, y)) 413 PRINT_ERR_MISC ("2E-6110"); 414 415 /* case where EXP(x) > 20414, thus outside the decimal128 range */ 416 mpfr_set_ui_2exp (x, 1, 20414, MPFR_RNDN); 417 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 418 MPFR_ASSERTN(d == DEC128_MAX); 419 d = mpfr_get_decimal128 (x, MPFR_RNDA); 420 MPFR_ASSERTN(d > DEC128_MAX); /* implies d = +Inf */ 421 mpfr_set_si_2exp (x, -1, 20414, MPFR_RNDN); 422 d = mpfr_get_decimal128 (x, MPFR_RNDZ); 423 MPFR_ASSERTN(d == -DEC128_MAX); 424 d = mpfr_get_decimal128 (x, MPFR_RNDA); 425 MPFR_ASSERTN(d < -DEC128_MAX); /* implies d = -Inf */ 426 427 /* case where EXP(x) = 20414, at the limit of the decimal128 range */ 428 mpfr_set_ui_2exp (x, 3, 20412, MPFR_RNDN); /* 3*2^20412 > 9.999...E6144 */ 429 d = mpfr_get_decimal128 (x, MPFR_RNDN); 430 MPFR_ASSERTN(d > DEC128_MAX); /* implies d = +Inf */ 431 mpfr_set_si_2exp (x, -3, 20412, MPFR_RNDN); 432 d = mpfr_get_decimal128 (x, MPFR_RNDN); 433 MPFR_ASSERTN(d < -DEC128_MAX); /* implies d = -Inf */ 434 435 { 436 unsigned long i; 437 for (i = 1; i < 1000; i++) 438 { 439 mpfr_set_ui_2exp (x, i, 20403, MPFR_RNDN); 440 d = mpfr_get_decimal128 (x, MPFR_RNDN); 441 mpfr_set_decimal128 (x, d, MPFR_RNDN); 442 MPFR_ASSERTN(mpfr_cmp_ui_2exp (x, i, 20403) == 0); 443 } 444 } 445 446 mpfr_clear (x); 447 mpfr_clear (y); 448 } 449 450 static void 451 noncanonical (void) 452 { 453 /* The code below assumes BID. */ 454 #if HAVE_DECIMAL128_IEEE && defined(DECIMAL_BID_FORMAT) 455 union ieee_decimal128 x; 456 457 MPFR_ASSERTN (sizeof (x) == 16); 458 /* produce a non-canonical decimal128 with Gh >= 24 */ 459 x.d128 = 1; 460 /* if BID, we have sig=0, comb=49408, t0=t1=t2=0, t3=1 */ 461 if (x.s.sig == 0 && x.s.comb == 49408 && x.s.t0 == 0 && x.s.t1 == 0 && 462 x.s.t2 == 0 && x.s.t3 == 1) 463 { 464 /* The volatile below avoids _Decimal128 constant propagation, which is 465 buggy for non-canonical encoding in various GCC versions on the x86 466 and x86_64 targets: failure in the second test below ("Error 2") 467 with gcc (Debian 20190820-1) 10.0.0 20190820 (experimental) 468 [trunk revision 274744]. The MPFR test was not failing with previous 469 GCC versions, not even with gcc (Debian 20190719-1) 10.0.0 20190718 470 (experimental) [trunk revision 273586] (contrary to the similar test 471 in tget_set_d64.c). More information at: 472 https://gcc.gnu.org/bugzilla/show_bug.cgi?id=91226 473 */ 474 volatile _Decimal128 d = 9999999999999999999999999999999999.dl; 475 mpfr_t y; 476 477 x.s.comb = 98560; /* force Gh >= 24 thus a non-canonical number 478 (significand >= 2^113 > 20^34-1) */ 479 mpfr_init2 (y, 113); 480 mpfr_set_decimal128 (y, x.d128, MPFR_RNDN); 481 if (MPFR_NOTZERO (y) || MPFR_IS_NEG (y)) 482 { 483 int i; 484 printf ("Error 1 in noncanonical on"); 485 for (i = 0; i < 16; i++) 486 printf (" %02X", ((unsigned char *)&x)[i]); 487 printf ("\nExpected +0, got:\n"); 488 mpfr_dump (y); 489 exit (1); 490 } 491 492 /* now construct a case Gh < 24, but where the significand exceeds 493 10^34-1 */ 494 x.d128 = d; 495 /* should give sig=0, comb=49415, t0=11529, t1=3199043520, 496 t2=932023907, t3=4294967295 */ 497 x.s.t3 ++; /* should give 0 */ 498 x.s.t2 += (x.s.t3 == 0); 499 /* now the significand is 10^34 */ 500 mpfr_set_decimal128 (y, x.d128, MPFR_RNDN); 501 if (MPFR_NOTZERO (y) || MPFR_IS_NEG (y)) 502 { 503 int i; 504 printf ("Error 2 in noncanonical on"); 505 for (i = 0; i < 16; i++) 506 printf (" %02X", ((unsigned char *)&x)[i]); 507 printf ("\nExpected +0, got:\n"); 508 mpfr_dump (y); 509 exit (1); 510 } 511 512 mpfr_clear (y); 513 } 514 else 515 printf ("Warning! Unexpected value of x in noncanonical.\n"); 516 #endif 517 } 518 519 /* generate random sequences of 16 bytes and interpret them as _Decimal128 */ 520 static void 521 check_random_bytes (void) 522 { 523 union { 524 _Decimal128 d; 525 unsigned char c[16]; 526 } x; 527 int i; 528 mpfr_t y; 529 _Decimal128 e; 530 531 mpfr_init2 (y, 114); /* 114 = 1 + ceil(34*log(10)/log(2)), thus ensures 532 that if a decimal128 number is converted to a 114-bit 533 value and back, we should get the same value */ 534 for (i = 0; i < 100000; i++) 535 { 536 int j; 537 for (j = 0; j < 16; j++) 538 x.c[j] = randlimb () & 255; 539 mpfr_set_decimal128 (y, x.d, MPFR_RNDN); 540 e = mpfr_get_decimal128 (y, MPFR_RNDN); 541 if (!mpfr_nan_p (y)) 542 if (x.d != e) 543 { 544 printf ("check_random_bytes failed\n"); 545 printf ("x.d="); print_decimal128 (x.d); 546 printf ("y="); mpfr_dump (y); 547 printf ("e="); print_decimal128 (e); 548 exit (1); 549 } 550 } 551 mpfr_clear (y); 552 } 553 554 int 555 main (int argc, char *argv[]) 556 { 557 int verbose = argc > 1; 558 559 tests_start_mpfr (); 560 mpfr_test_init (); 561 562 if (verbose) 563 { 564 #ifdef DECIMAL_DPD_FORMAT 565 printf ("Using DPD encoding\n"); 566 #endif 567 #ifdef DECIMAL_BID_FORMAT 568 printf ("Using BID encoding\n"); 569 #endif 570 } 571 572 #if !defined(MPFR_ERRDIVZERO) 573 check_random_bytes (); 574 #endif 575 test_set (); 576 powers_of_10 (); 577 #if !defined(MPFR_ERRDIVZERO) 578 check_misc (); 579 #endif 580 noncanonical (); 581 582 tests_end_mpfr (); 583 return 0; 584 } 585 586 #else /* MPFR_WANT_DECIMAL_FLOATS */ 587 588 int 589 main (void) 590 { 591 return 77; 592 } 593 594 #endif /* MPFR_WANT_DECIMAL_FLOATS */ 595