1 /* Test file for mpfr_add and mpfr_sub. 2 3 Copyright 1999-2016 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 http://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 #define N 30000 24 25 #include <stdio.h> 26 #include <stdlib.h> 27 #include <float.h> 28 29 #include "mpfr-test.h" 30 31 /* If the precisions are the same, we want to test both mpfr_add1sp 32 and mpfr_add1. */ 33 34 static int usesp; 35 36 static int 37 test_add (mpfr_ptr a, mpfr_srcptr b, mpfr_srcptr c, mpfr_rnd_t rnd_mode) 38 { 39 int res; 40 #ifdef CHECK_EXTERNAL 41 int ok = rnd_mode == MPFR_RNDN && mpfr_number_p (b) && mpfr_number_p (c); 42 if (ok) 43 { 44 mpfr_print_raw (b); 45 printf (" "); 46 mpfr_print_raw (c); 47 } 48 #endif 49 if (usesp || MPFR_ARE_SINGULAR(b,c) || MPFR_SIGN(b) != MPFR_SIGN(c)) 50 res = mpfr_add (a, b, c, rnd_mode); 51 else 52 { 53 if (MPFR_GET_EXP(b) < MPFR_GET_EXP(c)) 54 res = mpfr_add1(a, c, b, rnd_mode); 55 else 56 res = mpfr_add1(a, b, c, rnd_mode); 57 } 58 #ifdef CHECK_EXTERNAL 59 if (ok) 60 { 61 printf (" "); 62 mpfr_print_raw (a); 63 printf ("\n"); 64 } 65 #endif 66 return res; 67 } 68 69 /* checks that xs+ys gives the expected result zs */ 70 static void 71 check (const char *xs, const char *ys, mpfr_rnd_t rnd_mode, 72 unsigned int px, unsigned int py, unsigned int pz, const char *zs) 73 { 74 mpfr_t xx,yy,zz; 75 76 mpfr_init2 (xx, px); 77 mpfr_init2 (yy, py); 78 mpfr_init2 (zz, pz); 79 80 mpfr_set_str1 (xx, xs); 81 mpfr_set_str1 (yy, ys); 82 test_add (zz, xx, yy, rnd_mode); 83 if (mpfr_cmp_str1 (zz, zs) ) 84 { 85 printf ("expected sum is %s, got ", zs); 86 mpfr_out_str(stdout, 10, 0, zz, MPFR_RNDN); 87 printf ("mpfr_add failed for x=%s y=%s with rnd_mode=%s\n", 88 xs, ys, mpfr_print_rnd_mode (rnd_mode)); 89 exit (1); 90 } 91 mpfr_clears (xx, yy, zz, (mpfr_ptr) 0); 92 } 93 94 static void 95 check2b (const char *xs, int px, 96 const char *ys, int py, 97 const char *rs, int pz, 98 mpfr_rnd_t rnd_mode) 99 { 100 mpfr_t xx, yy, zz; 101 102 mpfr_init2 (xx,px); 103 mpfr_init2 (yy,py); 104 mpfr_init2 (zz,pz); 105 mpfr_set_str_binary (xx, xs); 106 mpfr_set_str_binary (yy, ys); 107 test_add (zz, xx, yy, rnd_mode); 108 if (mpfr_cmp_str (zz, rs, 2, MPFR_RNDN)) 109 { 110 printf ("(2) x=%s,%d y=%s,%d pz=%d,rnd=%s\n", 111 xs, px, ys, py, pz, mpfr_print_rnd_mode (rnd_mode)); 112 printf ("got "); mpfr_print_binary(zz); puts (""); 113 mpfr_set_str(zz, rs, 2, MPFR_RNDN); 114 printf ("instead of "); mpfr_print_binary(zz); puts (""); 115 exit (1); 116 } 117 mpfr_clear(xx); mpfr_clear(yy); mpfr_clear(zz); 118 } 119 120 static void 121 check64 (void) 122 { 123 mpfr_t x, t, u; 124 125 mpfr_init (x); 126 mpfr_init (t); 127 mpfr_init (u); 128 129 mpfr_set_prec (x, 29); 130 mpfr_set_str_binary (x, "1.1101001000101111011010010110e-3"); 131 mpfr_set_prec (t, 58); 132 mpfr_set_str_binary (t, "0.11100010011111001001100110010111110110011000000100101E-1"); 133 mpfr_set_prec (u, 29); 134 test_add (u, x, t, MPFR_RNDD); 135 mpfr_set_str_binary (t, "1.0101011100001000011100111110e-1"); 136 if (mpfr_cmp (u, t)) 137 { 138 printf ("mpfr_add(u, x, t) failed for prec(x)=29, prec(t)=58\n"); 139 printf ("expected "); mpfr_out_str (stdout, 2, 29, t, MPFR_RNDN); 140 puts (""); 141 printf ("got "); mpfr_out_str (stdout, 2, 29, u, MPFR_RNDN); 142 puts (""); 143 exit(1); 144 } 145 146 mpfr_set_prec (x, 4); 147 mpfr_set_str_binary (x, "-1.0E-2"); 148 mpfr_set_prec (t, 2); 149 mpfr_set_str_binary (t, "-1.1e-2"); 150 mpfr_set_prec (u, 2); 151 test_add (u, x, t, MPFR_RNDN); 152 if (MPFR_MANT(u)[0] << 2) 153 { 154 printf ("result not normalized for prec=2\n"); 155 mpfr_print_binary (u); puts (""); 156 exit (1); 157 } 158 mpfr_set_str_binary (t, "-1.0e-1"); 159 if (mpfr_cmp (u, t)) 160 { 161 printf ("mpfr_add(u, x, t) failed for prec(x)=4, prec(t)=2\n"); 162 printf ("expected -1.0e-1\n"); 163 printf ("got "); mpfr_out_str (stdout, 2, 4, u, MPFR_RNDN); 164 puts (""); 165 exit (1); 166 } 167 168 mpfr_set_prec (x, 8); 169 mpfr_set_str_binary (x, "-0.10011010"); /* -77/128 */ 170 mpfr_set_prec (t, 4); 171 mpfr_set_str_binary (t, "-1.110e-5"); /* -7/128 */ 172 mpfr_set_prec (u, 4); 173 test_add (u, x, t, MPFR_RNDN); /* should give -5/8 */ 174 mpfr_set_str_binary (t, "-1.010e-1"); 175 if (mpfr_cmp (u, t)) { 176 printf ("mpfr_add(u, x, t) failed for prec(x)=8, prec(t)=4\n"); 177 printf ("expected -1.010e-1\n"); 178 printf ("got "); mpfr_out_str (stdout, 2, 4, u, MPFR_RNDN); 179 puts (""); 180 exit (1); 181 } 182 183 mpfr_set_prec (x, 112); mpfr_set_prec (t, 98); mpfr_set_prec (u, 54); 184 mpfr_set_str_binary (x, "-0.11111100100000000011000011100000101101010001000111E-401"); 185 mpfr_set_str_binary (t, "0.10110000100100000101101100011111111011101000111000101E-464"); 186 test_add (u, x, t, MPFR_RNDN); 187 if (mpfr_cmp (u, x)) 188 { 189 printf ("mpfr_add(u, x, t) failed for prec(x)=112, prec(t)=98\n"); 190 exit (1); 191 } 192 193 mpfr_set_prec (x, 92); mpfr_set_prec (t, 86); mpfr_set_prec (u, 53); 194 mpfr_set_str (x, "-5.03525136761487735093e-74", 10, MPFR_RNDN); 195 mpfr_set_str (t, "8.51539046314262304109e-91", 10, MPFR_RNDN); 196 test_add (u, x, t, MPFR_RNDN); 197 if (mpfr_cmp_str1 (u, "-5.0352513676148773509283672e-74") ) 198 { 199 printf ("mpfr_add(u, x, t) failed for prec(x)=92, prec(t)=86\n"); 200 exit (1); 201 } 202 203 mpfr_set_prec(x, 53); mpfr_set_prec(t, 76); mpfr_set_prec(u, 76); 204 mpfr_set_str_binary(x, "-0.10010010001001011011110000000000001010011011011110001E-32"); 205 mpfr_set_str_binary(t, "-0.1011000101110010000101111111011111010001110011110111100110101011110010011111"); 206 mpfr_sub(u, x, t, MPFR_RNDU); 207 mpfr_set_str_binary(t, "0.1011000101110010000101111111011100111111101010011011110110101011101000000100"); 208 if (mpfr_cmp(u,t)) 209 { 210 printf ("expect "); mpfr_print_binary(t); puts (""); 211 printf ("mpfr_add failed for precisions 53-76\n"); 212 exit (1); 213 } 214 mpfr_set_prec(x, 53); mpfr_set_prec(t, 108); mpfr_set_prec(u, 108); 215 mpfr_set_str_binary(x, "-0.10010010001001011011110000000000001010011011011110001E-32"); 216 mpfr_set_str_binary(t, "-0.101100010111001000010111111101111101000111001111011110011010101111001001111000111011001110011000000000111111"); 217 mpfr_sub(u, x, t, MPFR_RNDU); 218 mpfr_set_str_binary(t, "0.101100010111001000010111111101110011111110101001101111011010101110100000001011000010101110011000000000111111"); 219 if (mpfr_cmp(u,t)) 220 { 221 printf ("expect "); mpfr_print_binary(t); puts (""); 222 printf ("mpfr_add failed for precisions 53-108\n"); 223 exit (1); 224 } 225 mpfr_set_prec(x, 97); mpfr_set_prec(t, 97); mpfr_set_prec(u, 97); 226 mpfr_set_str_binary(x, "0.1111101100001000000001011000110111101000001011111000100001000101010100011111110010000000000000000E-39"); 227 mpfr_set_ui(t, 1, MPFR_RNDN); 228 test_add (u, x, t, MPFR_RNDN); 229 mpfr_set_str_binary(x, "0.1000000000000000000000000000000000000000111110110000100000000101100011011110100000101111100010001E1"); 230 if (mpfr_cmp(u,x)) 231 { 232 printf ("mpfr_add failed for precision 97\n"); 233 exit (1); 234 } 235 mpfr_set_prec(x, 128); mpfr_set_prec(t, 128); mpfr_set_prec(u, 128); 236 mpfr_set_str_binary(x, "0.10101011111001001010111011001000101100111101000000111111111011010100001100011101010001010111111101111010100110111111100101100010E-4"); 237 mpfr_set(t, x, MPFR_RNDN); 238 mpfr_sub(u, x, t, MPFR_RNDN); 239 mpfr_set_prec(x, 96); mpfr_set_prec(t, 96); mpfr_set_prec(u, 96); 240 mpfr_set_str_binary(x, "0.111000000001110100111100110101101001001010010011010011100111100011010100011001010011011011000010E-4"); 241 mpfr_set(t, x, MPFR_RNDN); 242 mpfr_sub(u, x, t, MPFR_RNDN); 243 mpfr_set_prec(x, 85); mpfr_set_prec(t, 85); mpfr_set_prec(u, 85); 244 mpfr_set_str_binary(x, "0.1111101110100110110110100010101011101001100010100011110110110010010011101100101111100E-4"); 245 mpfr_set_str_binary(t, "0.1111101110100110110110100010101001001000011000111000011101100101110100001110101010110E-4"); 246 mpfr_sub(u, x, t, MPFR_RNDU); 247 mpfr_sub(x, x, t, MPFR_RNDU); 248 if (mpfr_cmp(x, u) != 0) 249 { 250 printf ("Error in mpfr_sub: u=x-t and x=x-t give different results\n"); 251 exit (1); 252 } 253 if ((MPFR_MANT(u)[(MPFR_PREC(u)-1)/mp_bits_per_limb] & 254 ((mp_limb_t)1<<(mp_bits_per_limb-1)))==0) 255 { 256 printf ("Error in mpfr_sub: result is not msb-normalized (1)\n"); 257 exit (1); 258 } 259 mpfr_set_prec(x, 65); mpfr_set_prec(t, 65); mpfr_set_prec(u, 65); 260 mpfr_set_str_binary(x, "0.10011010101000110101010000000011001001001110001011101011111011101E623"); 261 mpfr_set_str_binary(t, "0.10011010101000110101010000000011001001001110001011101011111011100E623"); 262 mpfr_sub(u, x, t, MPFR_RNDU); 263 if (mpfr_cmp_ui_2exp(u, 1, 558)) 264 { /* 2^558 */ 265 printf ("Error (1) in mpfr_sub\n"); 266 exit (1); 267 } 268 269 mpfr_set_prec(x, 64); mpfr_set_prec(t, 64); mpfr_set_prec(u, 64); 270 mpfr_set_str_binary(x, "0.1000011110101111011110111111000011101011101111101101101100000100E-220"); 271 mpfr_set_str_binary(t, "0.1000011110101111011110111111000011101011101111101101010011111101E-220"); 272 test_add (u, x, t, MPFR_RNDU); 273 if ((MPFR_MANT(u)[0] & 1) != 1) 274 { 275 printf ("error in mpfr_add with rnd_mode=MPFR_RNDU\n"); 276 printf ("b= "); mpfr_print_binary(x); puts (""); 277 printf ("c= "); mpfr_print_binary(t); puts (""); 278 printf ("b+c="); mpfr_print_binary(u); puts (""); 279 exit (1); 280 } 281 282 /* bug found by Norbert Mueller, 14 Sep 2000 */ 283 mpfr_set_prec(x, 56); mpfr_set_prec(t, 83); mpfr_set_prec(u, 10); 284 mpfr_set_str_binary(x, "0.10001001011011001111101100110100000101111010010111010111E-7"); 285 mpfr_set_str_binary(t, "0.10001001011011001111101100110100000101111010010111010111000000000111110110110000100E-7"); 286 mpfr_sub(u, x, t, MPFR_RNDU); 287 288 /* array bound write found by Norbert Mueller, 26 Sep 2000 */ 289 mpfr_set_prec(x, 109); mpfr_set_prec(t, 153); mpfr_set_prec(u, 95); 290 mpfr_set_str_binary(x,"0.1001010000101011101100111000110001111111111111111111111111111111111111111111111111111111111111100000000000000E33"); 291 mpfr_set_str_binary(t,"-0.100101000010101110110011100011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011100101101000000100100001100110111E33"); 292 test_add (u, x, t, MPFR_RNDN); 293 294 /* array bound writes found by Norbert Mueller, 27 Sep 2000 */ 295 mpfr_set_prec(x, 106); mpfr_set_prec(t, 53); mpfr_set_prec(u, 23); 296 mpfr_set_str_binary(x, "-0.1000011110101111111001010001000100001011000000000000000000000000000000000000000000000000000000000000000000E-59"); 297 mpfr_set_str_binary(t, "-0.10000111101011111110010100010001101100011100110100000E-59"); 298 mpfr_sub(u, x, t, MPFR_RNDN); 299 mpfr_set_prec(x, 177); mpfr_set_prec(t, 217); mpfr_set_prec(u, 160); 300 mpfr_set_str_binary(x, "-0.111010001011010000111001001010010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E35"); 301 mpfr_set_str_binary(t, "0.1110100010110100001110010010100100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000111011010011100001111001E35"); 302 test_add (u, x, t, MPFR_RNDN); 303 mpfr_set_prec(x, 214); mpfr_set_prec(t, 278); mpfr_set_prec(u, 207); 304 mpfr_set_str_binary(x, "0.1000100110100110101101101101000000010000100111000001001110001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000E66"); 305 mpfr_set_str_binary(t, "-0.10001001101001101011011011010000000100001001110000010011100010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001111011111001001100011E66"); 306 test_add (u, x, t, MPFR_RNDN); 307 mpfr_set_prec(x, 32); mpfr_set_prec(t, 247); mpfr_set_prec(u, 223); 308 mpfr_set_str_binary(x, "0.10000000000000000000000000000000E1"); 309 mpfr_set_str_binary(t, "0.1111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111100000110001110100000100011110000101110110011101110100110110111111011010111100100000000000000000000000000E0"); 310 mpfr_sub(u, x, t, MPFR_RNDN); 311 if ((MPFR_MANT(u)[(MPFR_PREC(u)-1)/mp_bits_per_limb] & 312 ((mp_limb_t)1<<(mp_bits_per_limb-1)))==0) 313 { 314 printf ("Error in mpfr_sub: result is not msb-normalized (2)\n"); 315 exit (1); 316 } 317 318 /* bug found by Nathalie Revol, 21 March 2001 */ 319 mpfr_set_prec (x, 65); 320 mpfr_set_prec (t, 65); 321 mpfr_set_prec (u, 65); 322 mpfr_set_str_binary (x, "0.11100100101101001100111011111111110001101001000011101001001010010E-35"); 323 mpfr_set_str_binary (t, "0.10000000000000000000000000000000000001110010010110100110011110000E1"); 324 mpfr_sub (u, t, x, MPFR_RNDU); 325 if ((MPFR_MANT(u)[(MPFR_PREC(u)-1)/mp_bits_per_limb] & 326 ((mp_limb_t)1<<(mp_bits_per_limb-1)))==0) 327 { 328 printf ("Error in mpfr_sub: result is not msb-normalized (3)\n"); 329 exit (1); 330 } 331 332 /* bug found by Fabrice Rouillier, 27 Mar 2001 */ 333 mpfr_set_prec (x, 107); 334 mpfr_set_prec (t, 107); 335 mpfr_set_prec (u, 107); 336 mpfr_set_str_binary (x, "0.10111001001111010010001000000010111111011011011101000001001000101000000000000000000000000000000000000000000E315"); 337 mpfr_set_str_binary (t, "0.10000000000000000000000000000000000101110100100101110110000001100101011111001000011101111100100100111011000E350"); 338 mpfr_sub (u, x, t, MPFR_RNDU); 339 if ((MPFR_MANT(u)[(MPFR_PREC(u)-1)/mp_bits_per_limb] & 340 ((mp_limb_t)1<<(mp_bits_per_limb-1)))==0) 341 { 342 printf ("Error in mpfr_sub: result is not msb-normalized (4)\n"); 343 exit (1); 344 } 345 346 /* checks that NaN flag is correctly reset */ 347 mpfr_set_ui (t, 1, MPFR_RNDN); 348 mpfr_set_ui (u, 1, MPFR_RNDN); 349 mpfr_set_nan (x); 350 test_add (x, t, u, MPFR_RNDN); 351 if (mpfr_cmp_ui (x, 2)) 352 { 353 printf ("Error in mpfr_add: 1+1 gives "); 354 mpfr_out_str(stdout, 10, 0, x, MPFR_RNDN); 355 exit (1); 356 } 357 358 mpfr_clear(x); mpfr_clear(t); mpfr_clear(u); 359 } 360 361 /* check case when c does not overlap with a, but both b and c count 362 for rounding */ 363 static void 364 check_case_1b (void) 365 { 366 mpfr_t a, b, c; 367 unsigned int prec_a, prec_b, prec_c, dif; 368 369 mpfr_init (a); 370 mpfr_init (b); 371 mpfr_init (c); 372 373 { 374 prec_a = MPFR_PREC_MIN + (randlimb () % 63); 375 mpfr_set_prec (a, prec_a); 376 for (prec_b = prec_a + 2; prec_b <= 64; prec_b++) 377 { 378 dif = prec_b - prec_a; 379 mpfr_set_prec (b, prec_b); 380 /* b = 1 - 2^(-prec_a) + 2^(-prec_b) */ 381 mpfr_set_ui (b, 1, MPFR_RNDN); 382 mpfr_div_2exp (b, b, dif, MPFR_RNDN); 383 mpfr_sub_ui (b, b, 1, MPFR_RNDN); 384 mpfr_div_2exp (b, b, prec_a, MPFR_RNDN); 385 mpfr_add_ui (b, b, 1, MPFR_RNDN); 386 for (prec_c = dif; prec_c <= 64; prec_c++) 387 { 388 /* c = 2^(-prec_a) - 2^(-prec_b) */ 389 mpfr_set_prec (c, prec_c); 390 mpfr_set_si (c, -1, MPFR_RNDN); 391 mpfr_div_2exp (c, c, dif, MPFR_RNDN); 392 mpfr_add_ui (c, c, 1, MPFR_RNDN); 393 mpfr_div_2exp (c, c, prec_a, MPFR_RNDN); 394 test_add (a, b, c, MPFR_RNDN); 395 if (mpfr_cmp_ui (a, 1) != 0) 396 { 397 printf ("case (1b) failed for prec_a=%u, prec_b=%u," 398 " prec_c=%u\n", prec_a, prec_b, prec_c); 399 printf ("b="); mpfr_print_binary(b); puts (""); 400 printf ("c="); mpfr_print_binary(c); puts (""); 401 printf ("a="); mpfr_print_binary(a); puts (""); 402 exit (1); 403 } 404 } 405 } 406 } 407 408 mpfr_clear (a); 409 mpfr_clear (b); 410 mpfr_clear (c); 411 } 412 413 /* check case when c overlaps with a */ 414 static void 415 check_case_2 (void) 416 { 417 mpfr_t a, b, c, d; 418 419 mpfr_init2 (a, 300); 420 mpfr_init2 (b, 800); 421 mpfr_init2 (c, 500); 422 mpfr_init2 (d, 800); 423 424 mpfr_set_str_binary(a, "1E110"); /* a = 2^110 */ 425 mpfr_set_str_binary(b, "1E900"); /* b = 2^900 */ 426 mpfr_set_str_binary(c, "1E500"); /* c = 2^500 */ 427 test_add (c, c, a, MPFR_RNDZ); /* c = 2^500 + 2^110 */ 428 mpfr_sub (d, b, c, MPFR_RNDZ); /* d = 2^900 - 2^500 - 2^110 */ 429 test_add (b, b, c, MPFR_RNDZ); /* b = 2^900 + 2^500 + 2^110 */ 430 test_add (a, b, d, MPFR_RNDZ); /* a = 2^901 */ 431 if (mpfr_cmp_ui_2exp (a, 1, 901)) 432 { 433 printf ("b + d fails for b=2^900+2^500+2^110, d=2^900-2^500-2^110\n"); 434 printf ("expected 1.0e901, got "); 435 mpfr_out_str (stdout, 2, 0, a, MPFR_RNDN); 436 printf ("\n"); 437 exit (1); 438 } 439 440 mpfr_clear (a); 441 mpfr_clear (b); 442 mpfr_clear (c); 443 mpfr_clear (d); 444 } 445 446 /* checks when source and destination are equal */ 447 static void 448 check_same (void) 449 { 450 mpfr_t x; 451 452 mpfr_init(x); mpfr_set_ui(x, 1, MPFR_RNDZ); 453 test_add (x, x, x, MPFR_RNDZ); 454 if (mpfr_cmp_ui (x, 2)) 455 { 456 printf ("Error when all 3 operands are equal\n"); 457 exit (1); 458 } 459 mpfr_clear(x); 460 } 461 462 #define check53(x, y, r, z) check(x, y, r, 53, 53, 53, z) 463 464 #define MAX_PREC 256 465 466 static void 467 check_inexact (void) 468 { 469 mpfr_t x, y, z, u; 470 mpfr_prec_t px, py, pu, pz; 471 int inexact, cmp; 472 mpfr_rnd_t rnd; 473 474 mpfr_init (x); 475 mpfr_init (y); 476 mpfr_init (z); 477 mpfr_init (u); 478 479 mpfr_set_prec (x, 2); 480 mpfr_set_str_binary (x, "0.1E-4"); 481 mpfr_set_prec (u, 33); 482 mpfr_set_str_binary (u, "0.101110100101101100000000111100000E-1"); 483 mpfr_set_prec (y, 31); 484 if ((inexact = test_add (y, x, u, MPFR_RNDN))) 485 { 486 printf ("Wrong inexact flag (2): expected 0, got %d\n", inexact); 487 exit (1); 488 } 489 490 mpfr_set_prec (x, 2); 491 mpfr_set_str_binary (x, "0.1E-4"); 492 mpfr_set_prec (u, 33); 493 mpfr_set_str_binary (u, "0.101110100101101100000000111100000E-1"); 494 mpfr_set_prec (y, 28); 495 if ((inexact = test_add (y, x, u, MPFR_RNDN))) 496 { 497 printf ("Wrong inexact flag (1): expected 0, got %d\n", inexact); 498 exit (1); 499 } 500 501 for (px=2; px<MAX_PREC; px++) 502 { 503 mpfr_set_prec (x, px); 504 do 505 { 506 mpfr_urandomb (x, RANDS); 507 } 508 while (mpfr_cmp_ui (x, 0) == 0); 509 for (pu=2; pu<MAX_PREC; pu++) 510 { 511 mpfr_set_prec (u, pu); 512 do 513 { 514 mpfr_urandomb (u, RANDS); 515 } 516 while (mpfr_cmp_ui (u, 0) == 0); 517 { 518 py = MPFR_PREC_MIN + (randlimb () % (MAX_PREC - 1)); 519 mpfr_set_prec (y, py); 520 pz = (mpfr_cmpabs (x, u) >= 0) ? MPFR_EXP(x) - MPFR_EXP(u) 521 : MPFR_EXP(u) - MPFR_EXP(x); 522 /* x + u is exactly representable with precision 523 abs(EXP(x)-EXP(u)) + max(prec(x), prec(u)) + 1 */ 524 pz = pz + MAX(MPFR_PREC(x), MPFR_PREC(u)) + 1; 525 mpfr_set_prec (z, pz); 526 rnd = RND_RAND (); 527 if (test_add (z, x, u, rnd)) 528 { 529 printf ("z <- x + u should be exact\n"); 530 printf ("x="); mpfr_print_binary (x); puts (""); 531 printf ("u="); mpfr_print_binary (u); puts (""); 532 printf ("z="); mpfr_print_binary (z); puts (""); 533 exit (1); 534 } 535 { 536 rnd = RND_RAND (); 537 inexact = test_add (y, x, u, rnd); 538 cmp = mpfr_cmp (y, z); 539 if (((inexact == 0) && (cmp != 0)) || 540 ((inexact > 0) && (cmp <= 0)) || 541 ((inexact < 0) && (cmp >= 0))) 542 { 543 printf ("Wrong inexact flag for rnd=%s\n", 544 mpfr_print_rnd_mode(rnd)); 545 printf ("expected %d, got %d\n", cmp, inexact); 546 printf ("x="); mpfr_print_binary (x); puts (""); 547 printf ("u="); mpfr_print_binary (u); puts (""); 548 printf ("y= "); mpfr_print_binary (y); puts (""); 549 printf ("x+u="); mpfr_print_binary (z); puts (""); 550 exit (1); 551 } 552 } 553 } 554 } 555 } 556 557 mpfr_clear (x); 558 mpfr_clear (y); 559 mpfr_clear (z); 560 mpfr_clear (u); 561 } 562 563 static void 564 check_nans (void) 565 { 566 mpfr_t s, x, y; 567 568 mpfr_init2 (x, 8L); 569 mpfr_init2 (y, 8L); 570 mpfr_init2 (s, 8L); 571 572 /* +inf + -inf == nan */ 573 mpfr_set_inf (x, 1); 574 mpfr_set_inf (y, -1); 575 test_add (s, x, y, MPFR_RNDN); 576 MPFR_ASSERTN (mpfr_nan_p (s)); 577 578 /* +inf + 1 == +inf */ 579 mpfr_set_inf (x, 1); 580 mpfr_set_ui (y, 1L, MPFR_RNDN); 581 test_add (s, x, y, MPFR_RNDN); 582 MPFR_ASSERTN (mpfr_inf_p (s)); 583 MPFR_ASSERTN (mpfr_sgn (s) > 0); 584 585 /* -inf + 1 == -inf */ 586 mpfr_set_inf (x, -1); 587 mpfr_set_ui (y, 1L, MPFR_RNDN); 588 test_add (s, x, y, MPFR_RNDN); 589 MPFR_ASSERTN (mpfr_inf_p (s)); 590 MPFR_ASSERTN (mpfr_sgn (s) < 0); 591 592 /* 1 + +inf == +inf */ 593 mpfr_set_ui (x, 1L, MPFR_RNDN); 594 mpfr_set_inf (y, 1); 595 test_add (s, x, y, MPFR_RNDN); 596 MPFR_ASSERTN (mpfr_inf_p (s)); 597 MPFR_ASSERTN (mpfr_sgn (s) > 0); 598 599 /* 1 + -inf == -inf */ 600 mpfr_set_ui (x, 1L, MPFR_RNDN); 601 mpfr_set_inf (y, -1); 602 test_add (s, x, y, MPFR_RNDN); 603 MPFR_ASSERTN (mpfr_inf_p (s)); 604 MPFR_ASSERTN (mpfr_sgn (s) < 0); 605 606 mpfr_clear (x); 607 mpfr_clear (y); 608 mpfr_clear (s); 609 } 610 611 static void 612 check_alloc (void) 613 { 614 mpfr_t a; 615 616 mpfr_init2 (a, 10000); 617 mpfr_set_prec (a, 53); 618 mpfr_set_ui (a, 15236, MPFR_RNDN); 619 test_add (a, a, a, MPFR_RNDN); 620 mpfr_mul (a, a, a, MPFR_RNDN); 621 mpfr_div (a, a, a, MPFR_RNDN); 622 mpfr_sub (a, a, a, MPFR_RNDN); 623 mpfr_clear (a); 624 } 625 626 static void 627 check_overflow (void) 628 { 629 mpfr_t a, b, c; 630 mpfr_prec_t prec_a; 631 int r; 632 633 mpfr_init2 (a, 256); 634 mpfr_init2 (b, 256); 635 mpfr_init2 (c, 256); 636 637 mpfr_set_ui (b, 1, MPFR_RNDN); 638 mpfr_setmax (b, mpfr_get_emax ()); 639 mpfr_set_ui (c, 1, MPFR_RNDN); 640 mpfr_set_exp (c, mpfr_get_emax () - 192); 641 RND_LOOP(r) 642 for (prec_a = 128; prec_a < 512; prec_a += 64) 643 { 644 mpfr_set_prec (a, prec_a); 645 mpfr_clear_overflow (); 646 test_add (a, b, c, (mpfr_rnd_t) r); 647 if (!mpfr_overflow_p ()) 648 { 649 printf ("No overflow in check_overflow\n"); 650 exit (1); 651 } 652 } 653 654 mpfr_set_exp (c, mpfr_get_emax () - 512); 655 mpfr_set_prec (a, 256); 656 mpfr_clear_overflow (); 657 test_add (a, b, c, MPFR_RNDU); 658 if (!mpfr_overflow_p ()) 659 { 660 printf ("No overflow in check_overflow\n"); 661 exit (1); 662 } 663 664 mpfr_clear (a); 665 mpfr_clear (b); 666 mpfr_clear (c); 667 } 668 669 static void 670 check_1111 (void) 671 { 672 mpfr_t one; 673 long n; 674 675 mpfr_init2 (one, MPFR_PREC_MIN); 676 mpfr_set_ui (one, 1, MPFR_RNDN); 677 for (n = 0; n < N; n++) 678 { 679 mpfr_prec_t prec_a, prec_b, prec_c; 680 mpfr_exp_t tb=0, tc, diff; 681 mpfr_t a, b, c, s; 682 int m = 512; 683 int sb, sc; 684 int inex_a, inex_s; 685 mpfr_rnd_t rnd_mode; 686 687 prec_a = MPFR_PREC_MIN + (randlimb () % m); 688 prec_b = MPFR_PREC_MIN + (randlimb () % m); 689 prec_c = MPFR_PREC_MIN + (randlimb () % m); 690 mpfr_init2 (a, prec_a); 691 mpfr_init2 (b, prec_b); 692 mpfr_init2 (c, prec_c); 693 sb = randlimb () % 3; 694 if (sb != 0) 695 { 696 tb = 1 + (randlimb () % (prec_b - (sb != 2))); 697 mpfr_div_2ui (b, one, tb, MPFR_RNDN); 698 if (sb == 2) 699 mpfr_neg (b, b, MPFR_RNDN); 700 test_add (b, b, one, MPFR_RNDN); 701 } 702 else 703 mpfr_set (b, one, MPFR_RNDN); 704 tc = 1 + (randlimb () % (prec_c - 1)); 705 mpfr_div_2ui (c, one, tc, MPFR_RNDN); 706 sc = randlimb () % 2; 707 if (sc) 708 mpfr_neg (c, c, MPFR_RNDN); 709 test_add (c, c, one, MPFR_RNDN); 710 diff = (randlimb () % (2*m)) - m; 711 mpfr_mul_2si (c, c, diff, MPFR_RNDN); 712 rnd_mode = RND_RAND (); 713 inex_a = test_add (a, b, c, rnd_mode); 714 mpfr_init2 (s, MPFR_PREC_MIN + 2*m); 715 inex_s = test_add (s, b, c, MPFR_RNDN); /* exact */ 716 if (inex_s) 717 { 718 printf ("check_1111: result should have been exact.\n"); 719 exit (1); 720 } 721 inex_s = mpfr_prec_round (s, prec_a, rnd_mode); 722 if ((inex_a < 0 && inex_s >= 0) || 723 (inex_a == 0 && inex_s != 0) || 724 (inex_a > 0 && inex_s <= 0) || 725 !mpfr_equal_p (a, s)) 726 { 727 printf ("check_1111: results are different.\n"); 728 printf ("prec_a = %d, prec_b = %d, prec_c = %d\n", 729 (int) prec_a, (int) prec_b, (int) prec_c); 730 printf ("tb = %d, tc = %d, diff = %d, rnd = %s\n", 731 (int) tb, (int) tc, (int) diff, 732 mpfr_print_rnd_mode (rnd_mode)); 733 printf ("sb = %d, sc = %d\n", sb, sc); 734 printf ("a = "); mpfr_print_binary (a); puts (""); 735 printf ("s = "); mpfr_print_binary (s); puts (""); 736 printf ("inex_a = %d, inex_s = %d\n", inex_a, inex_s); 737 exit (1); 738 } 739 mpfr_clear (a); 740 mpfr_clear (b); 741 mpfr_clear (c); 742 mpfr_clear (s); 743 } 744 mpfr_clear (one); 745 } 746 747 static void 748 check_1minuseps (void) 749 { 750 static mpfr_prec_t prec_a[] = { 751 MPFR_PREC_MIN, 30, 31, 32, 33, 62, 63, 64, 65, 126, 127, 128, 129 752 }; 753 static int supp_b[] = { 754 0, 1, 2, 3, 4, 29, 30, 31, 32, 33, 34, 35, 61, 62, 63, 64, 65, 66, 67 755 }; 756 mpfr_t a, b, c; 757 unsigned int ia, ib, ic; 758 759 mpfr_init2 (c, MPFR_PREC_MIN); 760 761 for (ia = 0; ia < numberof (prec_a); ia++) 762 for (ib = 0; ib < numberof(supp_b); ib++) 763 { 764 mpfr_prec_t prec_b; 765 int rnd_mode; 766 767 prec_b = prec_a[ia] + supp_b[ib]; 768 769 mpfr_init2 (a, prec_a[ia]); 770 mpfr_init2 (b, prec_b); 771 772 mpfr_set_ui (c, 1, MPFR_RNDN); 773 mpfr_div_ui (b, c, prec_a[ia], MPFR_RNDN); 774 mpfr_sub (b, c, b, MPFR_RNDN); /* b = 1 - 2^(-prec_a) */ 775 776 for (ic = 0; ic < numberof(supp_b); ic++) 777 for (rnd_mode = 0; rnd_mode < MPFR_RND_MAX; rnd_mode++) 778 { 779 mpfr_t s; 780 int inex_a, inex_s; 781 782 mpfr_set_ui (c, 1, MPFR_RNDN); 783 mpfr_div_ui (c, c, prec_a[ia] + supp_b[ic], MPFR_RNDN); 784 inex_a = test_add (a, b, c, (mpfr_rnd_t) rnd_mode); 785 mpfr_init2 (s, 256); 786 inex_s = test_add (s, b, c, MPFR_RNDN); /* exact */ 787 if (inex_s) 788 { 789 printf ("check_1minuseps: result should have been exact " 790 "(ia = %u, ib = %u, ic = %u)\n", ia, ib, ic); 791 exit (1); 792 } 793 inex_s = mpfr_prec_round (s, prec_a[ia], (mpfr_rnd_t) rnd_mode); 794 if ((inex_a < 0 && inex_s >= 0) || 795 (inex_a == 0 && inex_s != 0) || 796 (inex_a > 0 && inex_s <= 0) || 797 !mpfr_equal_p (a, s)) 798 { 799 printf ("check_1minuseps: results are different.\n"); 800 printf ("ia = %u, ib = %u, ic = %u\n", ia, ib, ic); 801 exit (1); 802 } 803 mpfr_clear (s); 804 } 805 806 mpfr_clear (a); 807 mpfr_clear (b); 808 } 809 810 mpfr_clear (c); 811 } 812 813 /* Test case bk == 0 in add1.c (b has entirely been read and 814 c hasn't been taken into account). */ 815 static void 816 coverage_bk_eq_0 (void) 817 { 818 mpfr_t a, b, c; 819 int inex; 820 821 mpfr_init2 (a, GMP_NUMB_BITS); 822 mpfr_init2 (b, 2 * GMP_NUMB_BITS); 823 mpfr_init2 (c, GMP_NUMB_BITS); 824 825 mpfr_set_ui_2exp (b, 1, 2 * GMP_NUMB_BITS, MPFR_RNDN); 826 mpfr_sub_ui (b, b, 1, MPFR_RNDN); 827 /* b = 111...111 (in base 2) where the 1's fit 2 whole limbs */ 828 829 mpfr_set_ui_2exp (c, 1, -1, MPFR_RNDN); /* c = 1/2 */ 830 831 inex = mpfr_add (a, b, c, MPFR_RNDU); 832 mpfr_set_ui_2exp (c, 1, 2 * GMP_NUMB_BITS, MPFR_RNDN); 833 if (! mpfr_equal_p (a, c)) 834 { 835 printf ("Error in coverage_bk_eq_0\n"); 836 printf ("Expected "); 837 mpfr_dump (c); 838 printf ("Got "); 839 mpfr_dump (a); 840 exit (1); 841 } 842 MPFR_ASSERTN (inex > 0); 843 844 mpfr_clear (a); 845 mpfr_clear (b); 846 mpfr_clear (c); 847 } 848 849 static void 850 tests (void) 851 { 852 check_alloc (); 853 check_nans (); 854 check_inexact (); 855 check_case_1b (); 856 check_case_2 (); 857 check64(); 858 coverage_bk_eq_0 (); 859 860 check("293607738.0", "1.9967571564050541e-5", MPFR_RNDU, 64, 53, 53, 861 "2.9360773800002003e8"); 862 check("880524.0", "-2.0769715792901673e-5", MPFR_RNDN, 64, 53, 53, 863 "8.8052399997923023e5"); 864 check("1196426492.0", "-1.4218093058435347e-3", MPFR_RNDN, 64, 53, 53, 865 "1.1964264919985781e9"); 866 check("982013018.0", "-8.941829477291838e-7", MPFR_RNDN, 64, 53, 53, 867 "9.8201301799999905e8"); 868 check("1092583421.0", "1.0880649218158844e9", MPFR_RNDN, 64, 53, 53, 869 "2.1806483428158846e9"); 870 check("1.8476886419022969e-6", "961494401.0", MPFR_RNDN, 53, 64, 53, 871 "9.6149440100000179e8"); 872 check("-2.3222118418069868e5", "1229318102.0", MPFR_RNDN, 53, 64, 53, 873 "1.2290858808158193e9"); 874 check("-3.0399171300395734e-6", "874924868.0", MPFR_RNDN, 53, 64, 53, 875 "8.749248679999969e8"); 876 check("9.064246624706179e1", "663787413.0", MPFR_RNDN, 53, 64, 53, 877 "6.6378750364246619e8"); 878 check("-1.0954322421551264e2", "281806592.0", MPFR_RNDD, 53, 64, 53, 879 "2.8180648245677572e8"); 880 check("5.9836930386056659e-8", "1016217213.0", MPFR_RNDN, 53, 64, 53, 881 "1.0162172130000001e9"); 882 check("-1.2772161928500301e-7", "1237734238.0", MPFR_RNDN, 53, 64, 53, 883 "1.2377342379999998e9"); 884 check("-4.567291988483277e8", "1262857194.0", MPFR_RNDN, 53, 64, 53, 885 "8.0612799515167236e8"); 886 check("4.7719471752925262e7", "196089880.0", MPFR_RNDN, 53, 53, 53, 887 "2.4380935175292528e8"); 888 check("4.7719471752925262e7", "196089880.0", MPFR_RNDN, 53, 64, 53, 889 "2.4380935175292528e8"); 890 check("-1.716113812768534e-140", "1271212614.0", MPFR_RNDZ, 53, 64, 53, 891 "1.2712126139999998e9"); 892 check("-1.2927455200185474e-50", "1675676122.0", MPFR_RNDD, 53, 64, 53, 893 "1.6756761219999998e9"); 894 895 check53("1.22191250737771397120e+20", "948002822.0", MPFR_RNDN, 896 "122191250738719408128.0"); 897 check53("9966027674114492.0", "1780341389094537.0", MPFR_RNDN, 898 "11746369063209028.0"); 899 check53("2.99280481918991653800e+272", "5.34637717585790933424e+271", 900 MPFR_RNDN, "3.5274425367757071711e272"); 901 check_same(); 902 check53("6.14384195492641560499e-02", "-6.14384195401037683237e-02", 903 MPFR_RNDU, "9.1603877261370314499e-12"); 904 check53("1.16809465359248765399e+196", "7.92883212101990665259e+196", 905 MPFR_RNDU, "9.0969267746123943065e196"); 906 check53("3.14553393112021279444e-67", "3.14553401015952024126e-67", MPFR_RNDU, 907 "6.2910679412797336946e-67"); 908 909 check53("5.43885304644369509058e+185","-1.87427265794105342763e-57",MPFR_RNDN, 910 "5.4388530464436950905e185"); 911 check53("5.43885304644369509058e+185","-1.87427265794105342763e-57",MPFR_RNDZ, 912 "5.4388530464436944867e185"); 913 check53("5.43885304644369509058e+185","-1.87427265794105342763e-57",MPFR_RNDU, 914 "5.4388530464436950905e185"); 915 check53("5.43885304644369509058e+185","-1.87427265794105342763e-57",MPFR_RNDD, 916 "5.4388530464436944867e185"); 917 918 check2b("1.001010101110011000000010100101110010111001010000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e358",187, 919 "-1.11100111001101100010001111111110101101110001000000000000000000000000000000000000000000e160",87, 920 "1.001010101110011000000010100101110010111001010000000111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111e358",178, 921 MPFR_RNDD); 922 check2b("-1.111100100011100111010101010101001010100100000111001000000000000000000e481",70, 923 "1.1111000110100011110101111110110010010000000110101000000000000000e481",65, 924 "-1.001010111111101011010000001100011101100101000000000000000000e472",61, 925 MPFR_RNDD); 926 check2b("1.0100010111010000100101000000111110011100011001011010000000000000000000000000000000e516",83, 927 "-1.1001111000100001011100000001001100110011110010111111000000e541",59, 928 "-1.1001111000100001011011110111000001001011100000011110100000110001110011010011000000000000000000000000000000000000000000000000e541",125, 929 MPFR_RNDZ); 930 check2b("-1.0010111100000100110001011011010000000011000111101000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e261",155, 931 "-1.00111110100011e239",15, 932 "-1.00101111000001001100101010101110001100110001111010000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e261",159, 933 MPFR_RNDD); 934 check2b("-1.110111000011111011000000001001111101101001010100111000000000000000000000000e880",76, 935 "-1.1010010e-634",8, 936 "-1.11011100001111101100000000100111110110100101010011100000000000000000000000e880",75, 937 MPFR_RNDZ); 938 check2b("1.00100100110110101001010010101111000001011100100101010000000000000000000000000000e-530",81, 939 "-1.101101111100000111000011001010110011001011101001110100000e-908",58, 940 "1.00100100110110101001010010101111000001011100100101010e-530",54, 941 MPFR_RNDN); 942 check2b("1.0101100010010111101000000001000010010010011000111011000000000000000000000000000000000000000000000000000000000000000000e374",119, 943 "1.11100101100101e358",15, 944 "1.01011000100110011000010110100100100100100110001110110000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e374",150, 945 MPFR_RNDZ); 946 check2b("-1.10011001000010100000010100100110110010011111101111000000000000000000000000000000000000000000000000000000000000000000e-172",117, 947 "1.111011100000101010110000100100110100100001001000011100000000e-173",61, 948 "-1.0100010000001001010110011011101001001011101011110001000000000000000e-173",68, 949 MPFR_RNDZ); 950 check2b("-1.011110000111101011100001100110100011100101000011011000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000e-189",175, 951 "1.1e631",2, 952 "1.011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111e631",115, 953 MPFR_RNDZ); 954 check2b("-1.101011101001011101100011001000001100010100001101011000000000000000000000000000000000000000000e-449",94, 955 "-1.01111101010111000011000110011101000111001100110111100000000000000e-429",66, 956 "-1.01111101010111000100110010000110100100101111111111101100010100001101011000000000000000000000000000000000000000e-429",111, 957 MPFR_RNDU); 958 check2b("-1.101011101001011101100011001000001100010100001101011000000000000000000000000000000000000000000e-449",94, 959 "-1.01111101010111000011000110011101000111001100110111100000000000000e-429",66, 960 "-1.01111101010111000100110010000110100100101111111111101100010100001101011000000000000000000000000000000000000000e-429",111, 961 MPFR_RNDD); 962 check2b("-1.1001000011101000110000111110010100100101110101111100000000000000000000000000000000000000000000000000000000e-72",107, 963 "-1.001100011101100100010101101010101011010010111111010000000000000000000000000000e521",79, 964 "-1.00110001110110010001010110101010101101001011111101000000000000000000000000000000000000000000000001e521",99, 965 MPFR_RNDD); 966 check2b("-1.01010001111000000101010100100100110101011011100001110000000000e498",63, 967 "1.010000011010101111000100111100011100010101011110010100000000000e243",64, 968 "-1.010100011110000001010101001001001101010110111000011100000000000e498",64, 969 MPFR_RNDN); 970 check2b("1.00101100010101000011010000011000111111011110010111000000000000000000000000000000000000000000000000000000000e178",108, 971 "-1.10101101010101000110011011111001001101111111110000100000000e160",60, 972 "1.00101100010100111100100011000011111001000010011101110010000000001111100000000000000000000000000000000000e178",105, 973 MPFR_RNDN); 974 check2b("1.00110011010100111110011010110100111101110101100100110000000000000000000000000000000000000000000000e559",99, 975 "-1.011010110100111011100110100110011100000000111010011000000000000000e559",67, 976 "-1.101111111101011111111111001001100100011100001001100000000000000000000000000000000000000000000e556",94, 977 MPFR_RNDU); 978 check2b("-1.100000111100101001100111011100011011000001101001111100000000000000000000000000e843",79, 979 "-1.1101101010110000001001000100001100110011000110110111000000000000000000000000000000000000000000e414",95, 980 "-1.1000001111001010011001110111000110110000011010100000e843",53, 981 MPFR_RNDD); 982 check2b("-1.110110010110100010100011000110111001010000010111110000000000e-415",61, 983 "-1.0000100101100001111100110011111111110100011101101011000000000000000000e751",71, 984 "-1.00001001011000011111001100111111111101000111011010110e751",54, 985 MPFR_RNDN); 986 check2b("-1.1011011011110001001101010101001000010100010110111101000000000000000000000e258",74, 987 "-1.00011100010110110101001011000100100000100010101000010000000000000000000000000000000000000000000000e268",99, 988 "-1.0001110011001001000011110001000111010110101011110010011011110100000000000000000000000000000000000000e268",101, 989 MPFR_RNDD); 990 check2b("-1.1011101010011101011000000100100110101101101110000001000000000e629",62, 991 "1.111111100000011100100011100000011101100110111110111000000000000000000000000000000000000000000e525",94, 992 "-1.101110101001110101100000010010011010110110111000000011111111111111111111111111111111111111111111111111101e629",106, 993 MPFR_RNDD); 994 check2b("1.111001000010001100010000001100000110001011110111011000000000000000000000000000000000000e152",88, 995 "1.111110111001100100000100111111010111000100111111001000000000000000e152",67, 996 "1.1110111111011110000010101001011011101010000110110100e153",53, 997 MPFR_RNDN); 998 check2b("1.000001100011110010110000110100001010101101111011110100e696",55, 999 "-1.1011001111011100100001011110100101010101110111010101000000000000000000000000000000000000000000000000000000000000e730",113, 1000 "-1.1011001111011100100001011110100100010100010011100010e730",53, 1001 MPFR_RNDN); 1002 check2b("-1.11010111100001001111000001110101010010001111111001100000000000000000000000000000000000000000000000000000000000e530",111, 1003 "1.01110100010010000000010110111101011101000001111101100000000000000000000000000000000000000000000000e530",99, 1004 "-1.1000110011110011101010101101111101010011011111000000000000000e528",62, 1005 MPFR_RNDD); 1006 check2b("-1.0001100010010100111101101011101000100100010011100011000000000000000000000000000000000000000000000000000000000e733",110, 1007 "-1.001000000111110010100101010100110111001111011011001000000000000000000000000000000000000000000000000000000000e710",109, 1008 "-1.000110001001010011111000111110110001110110011000110110e733",55, 1009 MPFR_RNDN); 1010 check2b("-1.1101011110000100111100000111010101001000111111100110000000000000000000000e530",74, 1011 "1.01110100010010000000010110111101011101000001111101100000000000000000000000000000000000000000000000000000000000e530",111, 1012 "-1.10001100111100111010101011011111010100110111110000000000000000000000000000e528",75, 1013 MPFR_RNDU); 1014 check2b("1.00110011010100111110011010110100111101110101100100110000000000000000000000000000000000000000000000e559",99, 1015 "-1.011010110100111011100110100110011100000000111010011000000000000000e559",67, 1016 "-1.101111111101011111111111001001100100011100001001100000000000000000000000000000000000000000000e556",94, 1017 MPFR_RNDU); 1018 check2b("-1.100101111110110000000110111111011010011101101111100100000000000000e-624",67, 1019 "1.10111010101110100000010110101000000000010011100000100000000e-587",60, 1020 "1.1011101010111010000001011010011111110100011110001011111111001000000100101100010010000011100000000000000000000e-587",110, 1021 MPFR_RNDU); 1022 check2b("-1.10011001000010100000010100100110110010011111101111000000000000000000000000000000000000000000000000000000000000000000e-172",117, 1023 "1.111011100000101010110000100100110100100001001000011100000000e-173",61, 1024 "-1.0100010000001001010110011011101001001011101011110001000000000000000e-173",68, 1025 MPFR_RNDZ); 1026 check2b("1.1000111000110010101001010011010011101100010110001001000000000000000000000000000000000000000000000000e167",101, 1027 "1.0011110010000110000000101100100111000001110110110000000000000000000000000e167",74, 1028 "1.01100101010111000101001111111111010101110001100111001000000000000000000000000000000000000000000000000000e168",105, 1029 MPFR_RNDZ); 1030 check2b("1.100101111111110010100101110111100001110000100001010000000000000000000000000000000000000000000000e808",97, 1031 "-1.1110011001100000100000111111110000110010100111001011000000000000000000000000000000e807",83, 1032 "1.01001001100110001100011111000000000001011010010111010000000000000000000000000000000000000000000e807",96, 1033 MPFR_RNDN); 1034 check2b("1e128",128, 1035 "1e0",128, 1036 "100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001e0",256, 1037 MPFR_RNDN); 1038 1039 /* Checking double precision (53 bits) */ 1040 check53("-8.22183238641455905806e-19", "7.42227178769761587878e-19",MPFR_RNDD, 1041 "-7.9956059871694317927e-20"); 1042 check53("5.82106394662028628236e+234","-5.21514064202368477230e+89",MPFR_RNDD, 1043 "5.8210639466202855763e234"); 1044 check53("5.72931679569871602371e+122","-5.72886070363264321230e+122", 1045 MPFR_RNDN, "4.5609206607281141508e118"); 1046 check53("-5.09937369394650450820e+238", "2.70203299854862982387e+250", 1047 MPFR_RNDD, "2.7020329985435301323e250"); 1048 check53("-2.96695924472363684394e+27", "1.22842938251111500000e+16",MPFR_RNDD, 1049 "-2.96695924471135255027e27"); 1050 check53("1.74693641655743793422e-227", "-7.71776956366861843469e-229", 1051 MPFR_RNDN, "1.669758720920751867e-227"); 1052 /* x = -7883040437021647.0; for (i=0; i<468; i++) x = x / 2.0;*/ 1053 check53("-1.03432206392780011159e-125", "1.30127034799251347548e-133", 1054 MPFR_RNDN, 1055 "-1.0343220509150965661100887242027378881805094180354e-125"); 1056 check53("1.05824655795525779205e+71", "-1.06022698059744327881e+71",MPFR_RNDZ, 1057 "-1.9804226421854867632e68"); 1058 check53("-5.84204911040921732219e+240", "7.26658169050749590763e+240", 1059 MPFR_RNDD, "1.4245325800982785854e240"); 1060 check53("1.00944884131046636376e+221","2.33809162651471520268e+215",MPFR_RNDN, 1061 "1.0094511794020929787e221"); 1062 /*x = 7045852550057985.0; for (i=0; i<986; i++) x = x / 2.0;*/ 1063 check53("4.29232078932667367325e-278", 1064 "1.0773525047389793833221116707010783793203080117586e-281" 1065 , MPFR_RNDU, "4.2933981418314132787e-278"); 1066 check53("5.27584773801377058681e-80", "8.91207657803547196421e-91", MPFR_RNDN, 1067 "5.2758477381028917269e-80"); 1068 check53("2.99280481918991653800e+272", "5.34637717585790933424e+271", 1069 MPFR_RNDN, "3.5274425367757071711e272"); 1070 check53("4.67302514390488041733e-184", "2.18321376145645689945e-190", 1071 MPFR_RNDN, "4.6730273271186420541e-184"); 1072 check53("5.57294120336300389254e+71", "2.60596167942024924040e+65", MPFR_RNDZ, 1073 "5.5729438093246831053e71"); 1074 check53("6.6052588496951015469e24", "4938448004894539.0", MPFR_RNDU, 1075 "6.6052588546335505068e24"); 1076 check53("1.23056185051606761523e-190", "1.64589756643433857138e-181", 1077 MPFR_RNDU, "1.6458975676649006598e-181"); 1078 check53("2.93231171510175981584e-280", "3.26266919161341483877e-273", 1079 MPFR_RNDU, "3.2626694848445867288e-273"); 1080 check53("5.76707395945001907217e-58", "4.74752971449827687074e-51", MPFR_RNDD, 1081 "4.747530291205672325e-51"); 1082 check53("277363943109.0", "11.0", MPFR_RNDN, "277363943120.0"); 1083 check53("1.44791789689198883921e-140", "-1.90982880222349071284e-121", 1084 MPFR_RNDN, "-1.90982880222349071e-121"); 1085 1086 1087 /* tests for particular cases (Vincent Lefevre, 22 Aug 2001) */ 1088 check53("9007199254740992.0", "1.0", MPFR_RNDN, "9007199254740992.0"); 1089 check53("9007199254740994.0", "1.0", MPFR_RNDN, "9007199254740996.0"); 1090 check53("9007199254740992.0", "-1.0", MPFR_RNDN, "9007199254740991.0"); 1091 check53("9007199254740994.0", "-1.0", MPFR_RNDN, "9007199254740992.0"); 1092 check53("9007199254740996.0", "-1.0", MPFR_RNDN, "9007199254740996.0"); 1093 1094 check_overflow (); 1095 check_1111 (); 1096 check_1minuseps (); 1097 } 1098 1099 #define TEST_FUNCTION test_add 1100 #define TWO_ARGS 1101 #define RAND_FUNCTION(x) mpfr_random2(x, MPFR_LIMB_SIZE (x), randlimb () % 100, RANDS) 1102 #include "tgeneric.c" 1103 1104 int 1105 main (int argc, char *argv[]) 1106 { 1107 tests_start_mpfr (); 1108 1109 usesp = 0; 1110 tests (); 1111 1112 #ifndef CHECK_EXTERNAL /* no need to check twice */ 1113 usesp = 1; 1114 tests (); 1115 #endif 1116 test_generic (2, 1000, 100); 1117 1118 tests_end_mpfr (); 1119 return 0; 1120 } 1121