1 /* Copyright (C) 2007-2022 Free Software Foundation, Inc. 2 3 This file is part of GCC. 4 5 GCC is free software; you can redistribute it and/or modify it under 6 the terms of the GNU General Public License as published by the Free 7 Software Foundation; either version 3, or (at your option) any later 8 version. 9 10 GCC is distributed in the hope that it will be useful, but WITHOUT ANY 11 WARRANTY; without even the implied warranty of MERCHANTABILITY or 12 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 13 for more details. 14 15 Under Section 7 of GPL version 3, you are granted additional 16 permissions described in the GCC Runtime Library Exception, version 17 3.1, as published by the Free Software Foundation. 18 19 You should have received a copy of the GNU General Public License and 20 a copy of the GCC Runtime Library Exception along with this program; 21 see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 22 <http://www.gnu.org/licenses/>. */ 23 24 #include "bid_internal.h" 25 26 /***************************************************************************** 27 * BID128_to_uint32_rnint 28 ****************************************************************************/ 29 30 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 31 bid128_to_uint32_rnint, x) 32 33 unsigned int res; 34 UINT64 x_sign; 35 UINT64 x_exp; 36 int exp; // unbiased exponent 37 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 38 UINT64 tmp64; 39 BID_UI64DOUBLE tmp1; 40 unsigned int x_nr_bits; 41 int q, ind, shift; 42 UINT128 C1, C; 43 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 44 UINT256 fstar; 45 UINT256 P256; 46 47 // unpack x 48 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 49 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 50 C1.w[1] = x.w[1] & MASK_COEFF; 51 C1.w[0] = x.w[0]; 52 53 // check for NaN or Infinity 54 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 55 // x is special 56 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 57 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 58 // set invalid flag 59 *pfpsf |= INVALID_EXCEPTION; 60 // return Integer Indefinite 61 res = 0x80000000; 62 } else { // x is QNaN 63 // set invalid flag 64 *pfpsf |= INVALID_EXCEPTION; 65 // return Integer Indefinite 66 res = 0x80000000; 67 } 68 BID_RETURN (res); 69 } else { // x is not a NaN, so it must be infinity 70 if (!x_sign) { // x is +inf 71 // set invalid flag 72 *pfpsf |= INVALID_EXCEPTION; 73 // return Integer Indefinite 74 res = 0x80000000; 75 } else { // x is -inf 76 // set invalid flag 77 *pfpsf |= INVALID_EXCEPTION; 78 // return Integer Indefinite 79 res = 0x80000000; 80 } 81 BID_RETURN (res); 82 } 83 } 84 // check for non-canonical values (after the check for special values) 85 if ((C1.w[1] > 0x0001ed09bead87c0ull) 86 || (C1.w[1] == 0x0001ed09bead87c0ull 87 && (C1.w[0] > 0x378d8e63ffffffffull)) 88 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 89 res = 0x00000000; 90 BID_RETURN (res); 91 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 92 // x is 0 93 res = 0x00000000; 94 BID_RETURN (res); 95 } else { // x is not special and is not zero 96 97 // q = nr. of decimal digits in x 98 // determine first the nr. of bits in x 99 if (C1.w[1] == 0) { 100 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 101 // split the 64-bit value in two 32-bit halves to avoid rounding errors 102 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 103 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 104 x_nr_bits = 105 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 106 } else { // x < 2^32 107 tmp1.d = (double) (C1.w[0]); // exact conversion 108 x_nr_bits = 109 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 110 } 111 } else { // if x < 2^53 112 tmp1.d = (double) C1.w[0]; // exact conversion 113 x_nr_bits = 114 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 115 } 116 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 117 tmp1.d = (double) C1.w[1]; // exact conversion 118 x_nr_bits = 119 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 120 } 121 q = nr_digits[x_nr_bits - 1].digits; 122 if (q == 0) { 123 q = nr_digits[x_nr_bits - 1].digits1; 124 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 125 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 126 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 127 q++; 128 } 129 exp = (x_exp >> 49) - 6176; 130 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 131 // set invalid flag 132 *pfpsf |= INVALID_EXCEPTION; 133 // return Integer Indefinite 134 res = 0x80000000; 135 BID_RETURN (res); 136 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 137 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 138 // so x rounded to an integer may or may not fit in an unsigned 32-bit int 139 // the cases that do not fit are identified here; the ones that fit 140 // fall through and will be handled with other cases further, 141 // under '1 <= q + exp <= 10' 142 if (x_sign) { // if n < 0 and q + exp = 10 143 // if n < -1/2 then n cannot be converted to uint32 with RN 144 // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 1/2 145 // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x05, 1<=q<=34 146 if (q <= 11) { 147 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 148 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 149 if (tmp64 > 0x05ull) { 150 // set invalid flag 151 *pfpsf |= INVALID_EXCEPTION; 152 // return Integer Indefinite 153 res = 0x80000000; 154 BID_RETURN (res); 155 } 156 // else cases that can be rounded to a 32-bit int fall through 157 // to '1 <= q + exp <= 10' 158 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 159 // 0.c(0)c(1)...c(q-1) * 10^11 > 0x05 <=> 160 // C > 0x05 * 10^(q-11) where 1 <= q - 11 <= 23 161 // (scale 1/2 up) 162 tmp64 = 0x05ull; 163 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 164 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 165 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 166 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 167 } 168 if (C1.w[1] > C.w[1] || (C1.w[1] == C.w[1] && C1.w[0] > C.w[0])) { 169 // set invalid flag 170 *pfpsf |= INVALID_EXCEPTION; 171 // return Integer Indefinite 172 res = 0x80000000; 173 BID_RETURN (res); 174 } 175 // else cases that can be rounded to a 32-bit int fall through 176 // to '1 <= q + exp <= 10' 177 } 178 } else { // if n > 0 and q + exp = 10 179 // if n >= 2^32 - 1/2 then n is too large 180 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^32-1/2 181 // too large if 0.c(0)c(1)...c(q-1) * 10^11 >= 0x9fffffffb, 1<=q<=34 182 if (q <= 11) { 183 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 184 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 185 if (tmp64 >= 0x9fffffffbull) { 186 // set invalid flag 187 *pfpsf |= INVALID_EXCEPTION; 188 // return Integer Indefinite 189 res = 0x80000000; 190 BID_RETURN (res); 191 } 192 // else cases that can be rounded to a 32-bit int fall through 193 // to '1 <= q + exp <= 10' 194 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 195 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x9fffffffb <=> 196 // C >= 0x9fffffffb * 10^(q-11) where 1 <= q - 11 <= 23 197 // (scale 2^32-1/2 up) 198 tmp64 = 0x9fffffffbull; 199 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 200 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 201 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 202 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 203 } 204 if (C1.w[1] > C.w[1] 205 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 206 // set invalid flag 207 *pfpsf |= INVALID_EXCEPTION; 208 // return Integer Indefinite 209 res = 0x80000000; 210 BID_RETURN (res); 211 } 212 // else cases that can be rounded to a 32-bit int fall through 213 // to '1 <= q + exp <= 10' 214 } 215 } 216 } 217 // n is not too large to be converted to int32: -1/2 <= n < 2^32 - 1/2 218 // Note: some of the cases tested for above fall through to this point 219 if ((q + exp) < 0) { // n = +/-0.0...c(0)c(1)...c(q-1) 220 // return 0 221 res = 0x00000000; 222 BID_RETURN (res); 223 } else if ((q + exp) == 0) { // n = +/-0.c(0)c(1)...c(q-1) 224 // if 0.c(0)c(1)...c(q-1) <= 0.5 <=> c(0)c(1)...c(q-1) <= 5 * 10^(q-1) 225 // res = 0 226 // else if x > 0 227 // res = +1 228 // else // if x < 0 229 // invalid exc 230 ind = q - 1; 231 if (ind <= 18) { // 0 <= ind <= 18 232 if ((C1.w[1] == 0) && (C1.w[0] <= midpoint64[ind])) { 233 res = 0x00000000; // return 0 234 } else if (!x_sign) { // n > 0 235 res = 0x00000001; // return +1 236 } else { 237 res = 0x80000000; 238 *pfpsf |= INVALID_EXCEPTION; 239 } 240 } else { // 19 <= ind <= 33 241 if ((C1.w[1] < midpoint128[ind - 19].w[1]) 242 || ((C1.w[1] == midpoint128[ind - 19].w[1]) 243 && (C1.w[0] <= midpoint128[ind - 19].w[0]))) { 244 res = 0x00000000; // return 0 245 } else if (!x_sign) { // n > 0 246 res = 0x00000001; // return +1 247 } else { 248 res = 0x80000000; 249 *pfpsf |= INVALID_EXCEPTION; 250 } 251 } 252 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 253 if (x_sign) { // x <= -1 254 // set invalid flag 255 *pfpsf |= INVALID_EXCEPTION; 256 // return Integer Indefinite 257 res = 0x80000000; 258 BID_RETURN (res); 259 } 260 // 1 <= x < 2^32-1/2 so x can be rounded 261 // to nearest to a 32-bit unsigned integer 262 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 263 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 264 // chop off ind digits from the lower part of C1 265 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 266 tmp64 = C1.w[0]; 267 if (ind <= 19) { 268 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 269 } else { 270 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 271 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 272 } 273 if (C1.w[0] < tmp64) 274 C1.w[1]++; 275 // calculate C* and f* 276 // C* is actually floor(C*) in this case 277 // C* and f* need shifting and masking, as shown by 278 // shiftright128[] and maskhigh128[] 279 // 1 <= x <= 33 280 // kx = 10^(-x) = ten2mk128[ind - 1] 281 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 282 // the approximation of 10^(-x) was rounded up to 118 bits 283 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 284 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 285 Cstar.w[1] = P256.w[3]; 286 Cstar.w[0] = P256.w[2]; 287 fstar.w[3] = 0; 288 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 289 fstar.w[1] = P256.w[1]; 290 fstar.w[0] = P256.w[0]; 291 } else { // 22 <= ind - 1 <= 33 292 Cstar.w[1] = 0; 293 Cstar.w[0] = P256.w[3]; 294 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 295 fstar.w[2] = P256.w[2]; 296 fstar.w[1] = P256.w[1]; 297 fstar.w[0] = P256.w[0]; 298 } 299 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 300 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 301 // if (0 < f* < 10^(-x)) then the result is a midpoint 302 // if floor(C*) is even then C* = floor(C*) - logical right 303 // shift; C* has p decimal digits, correct by Prop. 1) 304 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 305 // shift; C* has p decimal digits, correct by Pr. 1) 306 // else 307 // C* = floor(C*) (logical right shift; C has p decimal digits, 308 // correct by Property 1) 309 // n = C* * 10^(e+x) 310 311 // shift right C* by Ex-128 = shiftright128[ind] 312 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 313 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 314 Cstar.w[0] = 315 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 316 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 317 } else { // 22 <= ind - 1 <= 33 318 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 319 } 320 // if the result was a midpoint it was rounded away from zero, so 321 // it will need a correction 322 // check for midpoints 323 if ((fstar.w[3] == 0) && (fstar.w[2] == 0) 324 && (fstar.w[1] || fstar.w[0]) 325 && (fstar.w[1] < ten2mk128trunc[ind - 1].w[1] 326 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 327 && fstar.w[0] <= ten2mk128trunc[ind - 1].w[0]))) { 328 // the result is a midpoint; round to nearest 329 if (Cstar.w[0] & 0x01) { // Cstar.w[0] is odd; MP in [EVEN, ODD] 330 // if floor(C*) is odd C = floor(C*) - 1; the result >= 1 331 Cstar.w[0]--; // Cstar.w[0] is now even 332 } // else MP in [ODD, EVEN] 333 } 334 res = Cstar.w[0]; // the result is positive 335 } else if (exp == 0) { 336 // 1 <= q <= 10 337 // res = C (exact) 338 res = C1.w[0]; 339 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 340 // res = C * 10^exp (exact) 341 res = C1.w[0] * ten2k64[exp]; 342 } 343 } 344 } 345 346 BID_RETURN (res); 347 } 348 349 /***************************************************************************** 350 * BID128_to_uint32_xrnint 351 ****************************************************************************/ 352 353 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 354 bid128_to_uint32_xrnint, x) 355 356 unsigned int res; 357 UINT64 x_sign; 358 UINT64 x_exp; 359 int exp; // unbiased exponent 360 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 361 UINT64 tmp64, tmp64A; 362 BID_UI64DOUBLE tmp1; 363 unsigned int x_nr_bits; 364 int q, ind, shift; 365 UINT128 C1, C; 366 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 367 UINT256 fstar; 368 UINT256 P256; 369 unsigned int tmp_inexact = 0; 370 371 // unpack x 372 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 373 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 374 C1.w[1] = x.w[1] & MASK_COEFF; 375 C1.w[0] = x.w[0]; 376 377 // check for NaN or Infinity 378 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 379 // x is special 380 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 381 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 382 // set invalid flag 383 *pfpsf |= INVALID_EXCEPTION; 384 // return Integer Indefinite 385 res = 0x80000000; 386 } else { // x is QNaN 387 // set invalid flag 388 *pfpsf |= INVALID_EXCEPTION; 389 // return Integer Indefinite 390 res = 0x80000000; 391 } 392 BID_RETURN (res); 393 } else { // x is not a NaN, so it must be infinity 394 if (!x_sign) { // x is +inf 395 // set invalid flag 396 *pfpsf |= INVALID_EXCEPTION; 397 // return Integer Indefinite 398 res = 0x80000000; 399 } else { // x is -inf 400 // set invalid flag 401 *pfpsf |= INVALID_EXCEPTION; 402 // return Integer Indefinite 403 res = 0x80000000; 404 } 405 BID_RETURN (res); 406 } 407 } 408 // check for non-canonical values (after the check for special values) 409 if ((C1.w[1] > 0x0001ed09bead87c0ull) 410 || (C1.w[1] == 0x0001ed09bead87c0ull 411 && (C1.w[0] > 0x378d8e63ffffffffull)) 412 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 413 res = 0x00000000; 414 BID_RETURN (res); 415 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 416 // x is 0 417 res = 0x00000000; 418 BID_RETURN (res); 419 } else { // x is not special and is not zero 420 421 // q = nr. of decimal digits in x 422 // determine first the nr. of bits in x 423 if (C1.w[1] == 0) { 424 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 425 // split the 64-bit value in two 32-bit halves to avoid rounding errors 426 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 427 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 428 x_nr_bits = 429 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 430 } else { // x < 2^32 431 tmp1.d = (double) (C1.w[0]); // exact conversion 432 x_nr_bits = 433 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 434 } 435 } else { // if x < 2^53 436 tmp1.d = (double) C1.w[0]; // exact conversion 437 x_nr_bits = 438 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 439 } 440 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 441 tmp1.d = (double) C1.w[1]; // exact conversion 442 x_nr_bits = 443 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 444 } 445 q = nr_digits[x_nr_bits - 1].digits; 446 if (q == 0) { 447 q = nr_digits[x_nr_bits - 1].digits1; 448 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 449 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 450 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 451 q++; 452 } 453 exp = (x_exp >> 49) - 6176; 454 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 455 // set invalid flag 456 *pfpsf |= INVALID_EXCEPTION; 457 // return Integer Indefinite 458 res = 0x80000000; 459 BID_RETURN (res); 460 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 461 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 462 // so x rounded to an integer may or may not fit in an unsigned 32-bit int 463 // the cases that do not fit are identified here; the ones that fit 464 // fall through and will be handled with other cases further, 465 // under '1 <= q + exp <= 10' 466 if (x_sign) { // if n < 0 and q + exp = 10 467 // if n < -1/2 then n cannot be converted to uint32 with RN 468 // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 1/2 469 // <=> 0.c(0)c(1)...c(q-1) * 10^11 > 0x05, 1<=q<=34 470 if (q <= 11) { 471 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 472 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 473 if (tmp64 > 0x05ull) { 474 // set invalid flag 475 *pfpsf |= INVALID_EXCEPTION; 476 // return Integer Indefinite 477 res = 0x80000000; 478 BID_RETURN (res); 479 } 480 // else cases that can be rounded to a 32-bit int fall through 481 // to '1 <= q + exp <= 10' 482 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 483 // 0.c(0)c(1)...c(q-1) * 10^11 > 0x05 <=> 484 // C > 0x05 * 10^(q-11) where 1 <= q - 11 <= 23 485 // (scale 1/2 up) 486 tmp64 = 0x05ull; 487 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 488 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 489 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 490 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 491 } 492 if (C1.w[1] > C.w[1] || (C1.w[1] == C.w[1] && C1.w[0] > C.w[0])) { 493 // set invalid flag 494 *pfpsf |= INVALID_EXCEPTION; 495 // return Integer Indefinite 496 res = 0x80000000; 497 BID_RETURN (res); 498 } 499 // else cases that can be rounded to a 32-bit int fall through 500 // to '1 <= q + exp <= 10' 501 } 502 } else { // if n > 0 and q + exp = 10 503 // if n >= 2^32 - 1/2 then n is too large 504 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^32-1/2 505 // too large if 0.c(0)c(1)...c(q-1) * 10^11 >= 0x9fffffffb, 1<=q<=34 506 if (q <= 11) { 507 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 508 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 509 if (tmp64 >= 0x9fffffffbull) { 510 // set invalid flag 511 *pfpsf |= INVALID_EXCEPTION; 512 // return Integer Indefinite 513 res = 0x80000000; 514 BID_RETURN (res); 515 } 516 // else cases that can be rounded to a 32-bit int fall through 517 // to '1 <= q + exp <= 10' 518 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 519 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x9fffffffb <=> 520 // C >= 0x9fffffffb * 10^(q-11) where 1 <= q - 11 <= 23 521 // (scale 2^32-1/2 up) 522 tmp64 = 0x9fffffffbull; 523 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 524 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 525 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 526 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 527 } 528 if (C1.w[1] > C.w[1] 529 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 530 // set invalid flag 531 *pfpsf |= INVALID_EXCEPTION; 532 // return Integer Indefinite 533 res = 0x80000000; 534 BID_RETURN (res); 535 } 536 // else cases that can be rounded to a 32-bit int fall through 537 // to '1 <= q + exp <= 10' 538 } 539 } 540 } 541 // n is not too large to be converted to int32: -1/2 <= n < 2^32 - 1/2 542 // Note: some of the cases tested for above fall through to this point 543 if ((q + exp) < 0) { // n = +/-0.0...c(0)c(1)...c(q-1) 544 // set inexact flag 545 *pfpsf |= INEXACT_EXCEPTION; 546 // return 0 547 res = 0x00000000; 548 BID_RETURN (res); 549 } else if ((q + exp) == 0) { // n = +/-0.c(0)c(1)...c(q-1) 550 // if 0.c(0)c(1)...c(q-1) <= 0.5 <=> c(0)c(1)...c(q-1) <= 5 * 10^(q-1) 551 // res = 0 552 // else if x > 0 553 // res = +1 554 // else // if x < 0 555 // invalid exc 556 ind = q - 1; 557 if (ind <= 18) { // 0 <= ind <= 18 558 if ((C1.w[1] == 0) && (C1.w[0] <= midpoint64[ind])) { 559 res = 0x00000000; // return 0 560 } else if (!x_sign) { // n > 0 561 res = 0x00000001; // return +1 562 } else { 563 res = 0x80000000; 564 *pfpsf |= INVALID_EXCEPTION; 565 BID_RETURN (res); 566 } 567 } else { // 19 <= ind <= 33 568 if ((C1.w[1] < midpoint128[ind - 19].w[1]) 569 || ((C1.w[1] == midpoint128[ind - 19].w[1]) 570 && (C1.w[0] <= midpoint128[ind - 19].w[0]))) { 571 res = 0x00000000; // return 0 572 } else if (!x_sign) { // n > 0 573 res = 0x00000001; // return +1 574 } else { 575 res = 0x80000000; 576 *pfpsf |= INVALID_EXCEPTION; 577 BID_RETURN (res); 578 } 579 } 580 // set inexact flag 581 *pfpsf |= INEXACT_EXCEPTION; 582 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 583 if (x_sign) { // x <= -1 584 // set invalid flag 585 *pfpsf |= INVALID_EXCEPTION; 586 // return Integer Indefinite 587 res = 0x80000000; 588 BID_RETURN (res); 589 } 590 // 1 <= x < 2^32-1/2 so x can be rounded 591 // to nearest to a 32-bit unsigned integer 592 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 593 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 594 // chop off ind digits from the lower part of C1 595 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 596 tmp64 = C1.w[0]; 597 if (ind <= 19) { 598 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 599 } else { 600 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 601 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 602 } 603 if (C1.w[0] < tmp64) 604 C1.w[1]++; 605 // calculate C* and f* 606 // C* is actually floor(C*) in this case 607 // C* and f* need shifting and masking, as shown by 608 // shiftright128[] and maskhigh128[] 609 // 1 <= x <= 33 610 // kx = 10^(-x) = ten2mk128[ind - 1] 611 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 612 // the approximation of 10^(-x) was rounded up to 118 bits 613 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 614 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 615 Cstar.w[1] = P256.w[3]; 616 Cstar.w[0] = P256.w[2]; 617 fstar.w[3] = 0; 618 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 619 fstar.w[1] = P256.w[1]; 620 fstar.w[0] = P256.w[0]; 621 } else { // 22 <= ind - 1 <= 33 622 Cstar.w[1] = 0; 623 Cstar.w[0] = P256.w[3]; 624 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 625 fstar.w[2] = P256.w[2]; 626 fstar.w[1] = P256.w[1]; 627 fstar.w[0] = P256.w[0]; 628 } 629 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 630 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 631 // if (0 < f* < 10^(-x)) then the result is a midpoint 632 // if floor(C*) is even then C* = floor(C*) - logical right 633 // shift; C* has p decimal digits, correct by Prop. 1) 634 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 635 // shift; C* has p decimal digits, correct by Pr. 1) 636 // else 637 // C* = floor(C*) (logical right shift; C has p decimal digits, 638 // correct by Property 1) 639 // n = C* * 10^(e+x) 640 641 // shift right C* by Ex-128 = shiftright128[ind] 642 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 643 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 644 Cstar.w[0] = 645 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 646 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 647 } else { // 22 <= ind - 1 <= 33 648 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 649 } 650 // determine inexactness of the rounding of C* 651 // if (0 < f* - 1/2 < 10^(-x)) then 652 // the result is exact 653 // else // if (f* - 1/2 > T*) then 654 // the result is inexact 655 if (ind - 1 <= 2) { 656 if (fstar.w[1] > 0x8000000000000000ull || 657 (fstar.w[1] == 0x8000000000000000ull 658 && fstar.w[0] > 0x0ull)) { 659 // f* > 1/2 and the result may be exact 660 tmp64 = fstar.w[1] - 0x8000000000000000ull; // f* - 1/2 661 if (tmp64 > ten2mk128trunc[ind - 1].w[1] 662 || (tmp64 == ten2mk128trunc[ind - 1].w[1] 663 && fstar.w[0] >= ten2mk128trunc[ind - 1].w[0])) { 664 // set the inexact flag 665 // *pfpsf |= INEXACT_EXCEPTION; 666 tmp_inexact = 1; 667 } // else the result is exact 668 } else { // the result is inexact; f2* <= 1/2 669 // set the inexact flag 670 // *pfpsf |= INEXACT_EXCEPTION; 671 tmp_inexact = 1; 672 } 673 } else if (ind - 1 <= 21) { // if 3 <= ind <= 21 674 if (fstar.w[3] > 0x0 || 675 (fstar.w[3] == 0x0 && fstar.w[2] > onehalf128[ind - 1]) || 676 (fstar.w[3] == 0x0 && fstar.w[2] == onehalf128[ind - 1] && 677 (fstar.w[1] || fstar.w[0]))) { 678 // f2* > 1/2 and the result may be exact 679 // Calculate f2* - 1/2 680 tmp64 = fstar.w[2] - onehalf128[ind - 1]; 681 tmp64A = fstar.w[3]; 682 if (tmp64 > fstar.w[2]) 683 tmp64A--; 684 if (tmp64A || tmp64 685 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 686 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 687 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 688 // set the inexact flag 689 // *pfpsf |= INEXACT_EXCEPTION; 690 tmp_inexact = 1; 691 } // else the result is exact 692 } else { // the result is inexact; f2* <= 1/2 693 // set the inexact flag 694 // *pfpsf |= INEXACT_EXCEPTION; 695 tmp_inexact = 1; 696 } 697 } else { // if 22 <= ind <= 33 698 if (fstar.w[3] > onehalf128[ind - 1] || 699 (fstar.w[3] == onehalf128[ind - 1] && 700 (fstar.w[2] || fstar.w[1] || fstar.w[0]))) { 701 // f2* > 1/2 and the result may be exact 702 // Calculate f2* - 1/2 703 tmp64 = fstar.w[3] - onehalf128[ind - 1]; 704 if (tmp64 || fstar.w[2] 705 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 706 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 707 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 708 // set the inexact flag 709 // *pfpsf |= INEXACT_EXCEPTION; 710 tmp_inexact = 1; 711 } // else the result is exact 712 } else { // the result is inexact; f2* <= 1/2 713 // set the inexact flag 714 // *pfpsf |= INEXACT_EXCEPTION; 715 tmp_inexact = 1; 716 } 717 } 718 719 // if the result was a midpoint it was rounded away from zero, so 720 // it will need a correction 721 // check for midpoints 722 if ((fstar.w[3] == 0) && (fstar.w[2] == 0) 723 && (fstar.w[1] || fstar.w[0]) 724 && (fstar.w[1] < ten2mk128trunc[ind - 1].w[1] 725 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 726 && fstar.w[0] <= ten2mk128trunc[ind - 1].w[0]))) { 727 // the result is a midpoint; round to nearest 728 if (Cstar.w[0] & 0x01) { // Cstar.w[0] is odd; MP in [EVEN, ODD] 729 // if floor(C*) is odd C = floor(C*) - 1; the result >= 1 730 Cstar.w[0]--; // Cstar.w[0] is now even 731 } // else MP in [ODD, EVEN] 732 } 733 res = Cstar.w[0]; // the result is positive 734 if (tmp_inexact) 735 *pfpsf |= INEXACT_EXCEPTION; 736 } else if (exp == 0) { 737 // 1 <= q <= 10 738 // res = C (exact) 739 res = C1.w[0]; 740 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 741 // res = C * 10^exp (exact) 742 res = C1.w[0] * ten2k64[exp]; 743 } 744 } 745 } 746 747 BID_RETURN (res); 748 } 749 750 /***************************************************************************** 751 * BID128_to_uint32_floor 752 ****************************************************************************/ 753 754 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 755 bid128_to_uint32_floor, x) 756 757 unsigned int res; 758 UINT64 x_sign; 759 UINT64 x_exp; 760 int exp; // unbiased exponent 761 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 762 UINT64 tmp64, tmp64A; 763 BID_UI64DOUBLE tmp1; 764 unsigned int x_nr_bits; 765 int q, ind, shift; 766 UINT128 C1, C; 767 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 768 UINT256 fstar; 769 UINT256 P256; 770 int is_inexact_gt_midpoint = 0; 771 int is_midpoint_lt_even = 0; 772 773 // unpack x 774 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 775 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 776 C1.w[1] = x.w[1] & MASK_COEFF; 777 C1.w[0] = x.w[0]; 778 779 // check for NaN or Infinity 780 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 781 // x is special 782 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 783 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 784 // set invalid flag 785 *pfpsf |= INVALID_EXCEPTION; 786 // return Integer Indefinite 787 res = 0x80000000; 788 } else { // x is QNaN 789 // set invalid flag 790 *pfpsf |= INVALID_EXCEPTION; 791 // return Integer Indefinite 792 res = 0x80000000; 793 } 794 BID_RETURN (res); 795 } else { // x is not a NaN, so it must be infinity 796 if (!x_sign) { // x is +inf 797 // set invalid flag 798 *pfpsf |= INVALID_EXCEPTION; 799 // return Integer Indefinite 800 res = 0x80000000; 801 } else { // x is -inf 802 // set invalid flag 803 *pfpsf |= INVALID_EXCEPTION; 804 // return Integer Indefinite 805 res = 0x80000000; 806 } 807 BID_RETURN (res); 808 } 809 } 810 // check for non-canonical values (after the check for special values) 811 if ((C1.w[1] > 0x0001ed09bead87c0ull) 812 || (C1.w[1] == 0x0001ed09bead87c0ull 813 && (C1.w[0] > 0x378d8e63ffffffffull)) 814 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 815 res = 0x00000000; 816 BID_RETURN (res); 817 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 818 // x is 0 819 res = 0x00000000; 820 BID_RETURN (res); 821 } else { // x is not special and is not zero 822 // x < 0 is invalid 823 if (x_sign) { 824 // set invalid flag 825 *pfpsf |= INVALID_EXCEPTION; 826 // return Integer Indefinite 827 res = 0x80000000; 828 BID_RETURN (res); 829 } 830 // x > 0 from this point on 831 // q = nr. of decimal digits in x 832 // determine first the nr. of bits in x 833 if (C1.w[1] == 0) { 834 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 835 // split the 64-bit value in two 32-bit halves to avoid rounding errors 836 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 837 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 838 x_nr_bits = 839 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 840 } else { // x < 2^32 841 tmp1.d = (double) (C1.w[0]); // exact conversion 842 x_nr_bits = 843 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 844 } 845 } else { // if x < 2^53 846 tmp1.d = (double) C1.w[0]; // exact conversion 847 x_nr_bits = 848 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 849 } 850 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 851 tmp1.d = (double) C1.w[1]; // exact conversion 852 x_nr_bits = 853 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 854 } 855 q = nr_digits[x_nr_bits - 1].digits; 856 if (q == 0) { 857 q = nr_digits[x_nr_bits - 1].digits1; 858 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 859 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 860 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 861 q++; 862 } 863 exp = (x_exp >> 49) - 6176; 864 865 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 866 // set invalid flag 867 *pfpsf |= INVALID_EXCEPTION; 868 // return Integer Indefinite 869 res = 0x80000000; 870 BID_RETURN (res); 871 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 872 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 873 // so x rounded to an integer may or may not fit in a signed 32-bit int 874 // the cases that do not fit are identified here; the ones that fit 875 // fall through and will be handled with other cases further, 876 // under '1 <= q + exp <= 10' 877 // n > 0 and q + exp = 10 878 // if n >= 2^32 then n is too large 879 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^32 880 // too large if 0.c(0)c(1)...c(q-1) * 10^11 >= 0xa00000000, 1<=q<=34 881 if (q <= 11) { 882 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 883 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 884 if (tmp64 >= 0xa00000000ull) { 885 // set invalid flag 886 *pfpsf |= INVALID_EXCEPTION; 887 // return Integer Indefinite 888 res = 0x80000000; 889 BID_RETURN (res); 890 } 891 // else cases that can be rounded to a 32-bit int fall through 892 // to '1 <= q + exp <= 10' 893 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 894 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0xa00000000 <=> 895 // C >= 0xa00000000 * 10^(q-11) where 1 <= q - 11 <= 23 896 // (scale 2^32 up) 897 tmp64 = 0xa00000000ull; 898 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 899 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 900 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 901 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 902 } 903 if (C1.w[1] > C.w[1] || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 904 // set invalid flag 905 *pfpsf |= INVALID_EXCEPTION; 906 // return Integer Indefinite 907 res = 0x80000000; 908 BID_RETURN (res); 909 } 910 // else cases that can be rounded to a 32-bit int fall through 911 // to '1 <= q + exp <= 10' 912 } 913 } 914 // n is not too large to be converted to int32: 0 <= n < 2^31 915 // Note: some of the cases tested for above fall through to this point 916 if ((q + exp) <= 0) { 917 // n = +0.0...c(0)c(1)...c(q-1) or n = +0.c(0)c(1)...c(q-1) 918 // return 0 919 res = 0x00000000; 920 BID_RETURN (res); 921 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 922 // 1 <= x < 2^32 so x can be rounded down to a 32-bit unsigned integer 923 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 924 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 925 // chop off ind digits from the lower part of C1 926 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 927 tmp64 = C1.w[0]; 928 if (ind <= 19) { 929 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 930 } else { 931 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 932 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 933 } 934 if (C1.w[0] < tmp64) 935 C1.w[1]++; 936 // calculate C* and f* 937 // C* is actually floor(C*) in this case 938 // C* and f* need shifting and masking, as shown by 939 // shiftright128[] and maskhigh128[] 940 // 1 <= x <= 33 941 // kx = 10^(-x) = ten2mk128[ind - 1] 942 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 943 // the approximation of 10^(-x) was rounded up to 118 bits 944 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 945 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 946 Cstar.w[1] = P256.w[3]; 947 Cstar.w[0] = P256.w[2]; 948 fstar.w[3] = 0; 949 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 950 fstar.w[1] = P256.w[1]; 951 fstar.w[0] = P256.w[0]; 952 } else { // 22 <= ind - 1 <= 33 953 Cstar.w[1] = 0; 954 Cstar.w[0] = P256.w[3]; 955 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 956 fstar.w[2] = P256.w[2]; 957 fstar.w[1] = P256.w[1]; 958 fstar.w[0] = P256.w[0]; 959 } 960 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 961 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 962 // if (0 < f* < 10^(-x)) then the result is a midpoint 963 // if floor(C*) is even then C* = floor(C*) - logical right 964 // shift; C* has p decimal digits, correct by Prop. 1) 965 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 966 // shift; C* has p decimal digits, correct by Pr. 1) 967 // else 968 // C* = floor(C*) (logical right shift; C has p decimal digits, 969 // correct by Property 1) 970 // n = C* * 10^(e+x) 971 972 // shift right C* by Ex-128 = shiftright128[ind] 973 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 974 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 975 Cstar.w[0] = 976 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 977 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 978 } else { // 22 <= ind - 1 <= 33 979 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 980 } 981 // determine inexactness of the rounding of C* 982 // if (0 < f* - 1/2 < 10^(-x)) then 983 // the result is exact 984 // else // if (f* - 1/2 > T*) then 985 // the result is inexact 986 if (ind - 1 <= 2) { 987 if (fstar.w[1] > 0x8000000000000000ull || 988 (fstar.w[1] == 0x8000000000000000ull 989 && fstar.w[0] > 0x0ull)) { 990 // f* > 1/2 and the result may be exact 991 tmp64 = fstar.w[1] - 0x8000000000000000ull; // f* - 1/2 992 if (tmp64 > ten2mk128trunc[ind - 1].w[1] 993 || (tmp64 == ten2mk128trunc[ind - 1].w[1] 994 && fstar.w[0] >= ten2mk128trunc[ind - 1].w[0])) { 995 } // else the result is exact 996 } else { // the result is inexact; f2* <= 1/2 997 is_inexact_gt_midpoint = 1; 998 } 999 } else if (ind - 1 <= 21) { // if 3 <= ind <= 21 1000 if (fstar.w[3] > 0x0 || 1001 (fstar.w[3] == 0x0 && fstar.w[2] > onehalf128[ind - 1]) || 1002 (fstar.w[3] == 0x0 && fstar.w[2] == onehalf128[ind - 1] && 1003 (fstar.w[1] || fstar.w[0]))) { 1004 // f2* > 1/2 and the result may be exact 1005 // Calculate f2* - 1/2 1006 tmp64 = fstar.w[2] - onehalf128[ind - 1]; 1007 tmp64A = fstar.w[3]; 1008 if (tmp64 > fstar.w[2]) 1009 tmp64A--; 1010 if (tmp64A || tmp64 1011 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 1012 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1013 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 1014 } // else the result is exact 1015 } else { // the result is inexact; f2* <= 1/2 1016 is_inexact_gt_midpoint = 1; 1017 } 1018 } else { // if 22 <= ind <= 33 1019 if (fstar.w[3] > onehalf128[ind - 1] || 1020 (fstar.w[3] == onehalf128[ind - 1] && 1021 (fstar.w[2] || fstar.w[1] || fstar.w[0]))) { 1022 // f2* > 1/2 and the result may be exact 1023 // Calculate f2* - 1/2 1024 tmp64 = fstar.w[3] - onehalf128[ind - 1]; 1025 if (tmp64 || fstar.w[2] 1026 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 1027 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1028 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 1029 } // else the result is exact 1030 } else { // the result is inexact; f2* <= 1/2 1031 is_inexact_gt_midpoint = 1; 1032 } 1033 } 1034 1035 // if the result was a midpoint it was rounded away from zero, so 1036 // it will need a correction 1037 // check for midpoints 1038 if ((fstar.w[3] == 0) && (fstar.w[2] == 0) 1039 && (fstar.w[1] || fstar.w[0]) 1040 && (fstar.w[1] < ten2mk128trunc[ind - 1].w[1] 1041 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1042 && fstar.w[0] <= ten2mk128trunc[ind - 1].w[0]))) { 1043 // the result is a midpoint; round to nearest 1044 if (Cstar.w[0] & 0x01) { // Cstar.w[0] is odd; MP in [EVEN, ODD] 1045 // if floor(C*) is odd C = floor(C*) - 1; the result >= 1 1046 Cstar.w[0]--; // Cstar.w[0] is now even 1047 is_inexact_gt_midpoint = 0; 1048 } else { // else MP in [ODD, EVEN] 1049 is_midpoint_lt_even = 1; 1050 is_inexact_gt_midpoint = 0; 1051 } 1052 } 1053 // general correction for RM 1054 if (is_midpoint_lt_even || is_inexact_gt_midpoint) { 1055 Cstar.w[0] = Cstar.w[0] - 1; 1056 } else { 1057 ; // the result is already correct 1058 } 1059 res = Cstar.w[0]; 1060 } else if (exp == 0) { 1061 // 1 <= q <= 10 1062 // res = +C (exact) 1063 res = C1.w[0]; 1064 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 1065 // res = +C * 10^exp (exact) 1066 res = C1.w[0] * ten2k64[exp]; 1067 } 1068 } 1069 } 1070 1071 BID_RETURN (res); 1072 } 1073 1074 /***************************************************************************** 1075 * BID128_to_uint32_xfloor 1076 ****************************************************************************/ 1077 1078 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 1079 bid128_to_uint32_xfloor, x) 1080 1081 unsigned int res; 1082 UINT64 x_sign; 1083 UINT64 x_exp; 1084 int exp; // unbiased exponent 1085 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 1086 UINT64 tmp64, tmp64A; 1087 BID_UI64DOUBLE tmp1; 1088 unsigned int x_nr_bits; 1089 int q, ind, shift; 1090 UINT128 C1, C; 1091 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 1092 UINT256 fstar; 1093 UINT256 P256; 1094 int is_inexact_gt_midpoint = 0; 1095 int is_midpoint_lt_even = 0; 1096 1097 // unpack x 1098 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 1099 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 1100 C1.w[1] = x.w[1] & MASK_COEFF; 1101 C1.w[0] = x.w[0]; 1102 1103 // check for NaN or Infinity 1104 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 1105 // x is special 1106 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 1107 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 1108 // set invalid flag 1109 *pfpsf |= INVALID_EXCEPTION; 1110 // return Integer Indefinite 1111 res = 0x80000000; 1112 } else { // x is QNaN 1113 // set invalid flag 1114 *pfpsf |= INVALID_EXCEPTION; 1115 // return Integer Indefinite 1116 res = 0x80000000; 1117 } 1118 BID_RETURN (res); 1119 } else { // x is not a NaN, so it must be infinity 1120 if (!x_sign) { // x is +inf 1121 // set invalid flag 1122 *pfpsf |= INVALID_EXCEPTION; 1123 // return Integer Indefinite 1124 res = 0x80000000; 1125 } else { // x is -inf 1126 // set invalid flag 1127 *pfpsf |= INVALID_EXCEPTION; 1128 // return Integer Indefinite 1129 res = 0x80000000; 1130 } 1131 BID_RETURN (res); 1132 } 1133 } 1134 // check for non-canonical values (after the check for special values) 1135 if ((C1.w[1] > 0x0001ed09bead87c0ull) 1136 || (C1.w[1] == 0x0001ed09bead87c0ull 1137 && (C1.w[0] > 0x378d8e63ffffffffull)) 1138 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 1139 res = 0x00000000; 1140 BID_RETURN (res); 1141 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 1142 // x is 0 1143 res = 0x00000000; 1144 BID_RETURN (res); 1145 } else { // x is not special and is not zero 1146 // x < 0 is invalid 1147 if (x_sign) { 1148 // set invalid flag 1149 *pfpsf |= INVALID_EXCEPTION; 1150 // return Integer Indefinite 1151 res = 0x80000000; 1152 BID_RETURN (res); 1153 } 1154 // x > 0 from this point on 1155 // q = nr. of decimal digits in x 1156 // determine first the nr. of bits in x 1157 if (C1.w[1] == 0) { 1158 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 1159 // split the 64-bit value in two 32-bit halves to avoid rounding errors 1160 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 1161 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 1162 x_nr_bits = 1163 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1164 } else { // x < 2^32 1165 tmp1.d = (double) (C1.w[0]); // exact conversion 1166 x_nr_bits = 1167 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1168 } 1169 } else { // if x < 2^53 1170 tmp1.d = (double) C1.w[0]; // exact conversion 1171 x_nr_bits = 1172 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1173 } 1174 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 1175 tmp1.d = (double) C1.w[1]; // exact conversion 1176 x_nr_bits = 1177 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1178 } 1179 q = nr_digits[x_nr_bits - 1].digits; 1180 if (q == 0) { 1181 q = nr_digits[x_nr_bits - 1].digits1; 1182 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 1183 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 1184 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 1185 q++; 1186 } 1187 exp = (x_exp >> 49) - 6176; 1188 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 1189 // set invalid flag 1190 *pfpsf |= INVALID_EXCEPTION; 1191 // return Integer Indefinite 1192 res = 0x80000000; 1193 BID_RETURN (res); 1194 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 1195 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 1196 // so x rounded to an integer may or may not fit in a signed 32-bit int 1197 // the cases that do not fit are identified here; the ones that fit 1198 // fall through and will be handled with other cases further, 1199 // under '1 <= q + exp <= 10' 1200 // n > 0 and q + exp = 10 1201 // if n >= 2^32 then n is too large 1202 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^32 1203 // too large if 0.c(0)c(1)...c(q-1) * 10^11 >= 0xa00000000, 1<=q<=34 1204 if (q <= 11) { 1205 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 1206 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 1207 if (tmp64 >= 0xa00000000ull) { 1208 // set invalid flag 1209 *pfpsf |= INVALID_EXCEPTION; 1210 // return Integer Indefinite 1211 res = 0x80000000; 1212 BID_RETURN (res); 1213 } 1214 // else cases that can be rounded to a 32-bit int fall through 1215 // to '1 <= q + exp <= 10' 1216 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 1217 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0xa00000000 <=> 1218 // C >= 0xa00000000 * 10^(q-11) where 1 <= q - 11 <= 23 1219 // (scale 2^32 up) 1220 tmp64 = 0xa00000000ull; 1221 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 1222 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 1223 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 1224 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 1225 } 1226 if (C1.w[1] > C.w[1] || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 1227 // set invalid flag 1228 *pfpsf |= INVALID_EXCEPTION; 1229 // return Integer Indefinite 1230 res = 0x80000000; 1231 BID_RETURN (res); 1232 } 1233 // else cases that can be rounded to a 32-bit int fall through 1234 // to '1 <= q + exp <= 10' 1235 } 1236 } 1237 // n is not too large to be converted to int32: 0 <= n < 2^31 1238 // Note: some of the cases tested for above fall through to this point 1239 if ((q + exp) <= 0) { 1240 // n = +0.0...c(0)c(1)...c(q-1) or n = +0.c(0)c(1)...c(q-1) 1241 // set inexact flag 1242 *pfpsf |= INEXACT_EXCEPTION; 1243 // return 0 1244 res = 0x00000000; 1245 BID_RETURN (res); 1246 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 1247 // 1 <= x < 2^32 so x can be rounded down to a 32-bit unsigned integer 1248 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 1249 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 1250 // chop off ind digits from the lower part of C1 1251 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 1252 tmp64 = C1.w[0]; 1253 if (ind <= 19) { 1254 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 1255 } else { 1256 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 1257 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 1258 } 1259 if (C1.w[0] < tmp64) 1260 C1.w[1]++; 1261 // calculate C* and f* 1262 // C* is actually floor(C*) in this case 1263 // C* and f* need shifting and masking, as shown by 1264 // shiftright128[] and maskhigh128[] 1265 // 1 <= x <= 33 1266 // kx = 10^(-x) = ten2mk128[ind - 1] 1267 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 1268 // the approximation of 10^(-x) was rounded up to 118 bits 1269 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 1270 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 1271 Cstar.w[1] = P256.w[3]; 1272 Cstar.w[0] = P256.w[2]; 1273 fstar.w[3] = 0; 1274 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 1275 fstar.w[1] = P256.w[1]; 1276 fstar.w[0] = P256.w[0]; 1277 } else { // 22 <= ind - 1 <= 33 1278 Cstar.w[1] = 0; 1279 Cstar.w[0] = P256.w[3]; 1280 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 1281 fstar.w[2] = P256.w[2]; 1282 fstar.w[1] = P256.w[1]; 1283 fstar.w[0] = P256.w[0]; 1284 } 1285 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 1286 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 1287 // if (0 < f* < 10^(-x)) then the result is a midpoint 1288 // if floor(C*) is even then C* = floor(C*) - logical right 1289 // shift; C* has p decimal digits, correct by Prop. 1) 1290 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 1291 // shift; C* has p decimal digits, correct by Pr. 1) 1292 // else 1293 // C* = floor(C*) (logical right shift; C has p decimal digits, 1294 // correct by Property 1) 1295 // n = C* * 10^(e+x) 1296 1297 // shift right C* by Ex-128 = shiftright128[ind] 1298 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 1299 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 1300 Cstar.w[0] = 1301 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 1302 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 1303 } else { // 22 <= ind - 1 <= 33 1304 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 1305 } 1306 // determine inexactness of the rounding of C* 1307 // if (0 < f* - 1/2 < 10^(-x)) then 1308 // the result is exact 1309 // else // if (f* - 1/2 > T*) then 1310 // the result is inexact 1311 if (ind - 1 <= 2) { 1312 if (fstar.w[1] > 0x8000000000000000ull || 1313 (fstar.w[1] == 0x8000000000000000ull 1314 && fstar.w[0] > 0x0ull)) { 1315 // f* > 1/2 and the result may be exact 1316 tmp64 = fstar.w[1] - 0x8000000000000000ull; // f* - 1/2 1317 if (tmp64 > ten2mk128trunc[ind - 1].w[1] 1318 || (tmp64 == ten2mk128trunc[ind - 1].w[1] 1319 && fstar.w[0] >= ten2mk128trunc[ind - 1].w[0])) { 1320 // set the inexact flag 1321 *pfpsf |= INEXACT_EXCEPTION; 1322 } // else the result is exact 1323 } else { // the result is inexact; f2* <= 1/2 1324 // set the inexact flag 1325 *pfpsf |= INEXACT_EXCEPTION; 1326 is_inexact_gt_midpoint = 1; 1327 } 1328 } else if (ind - 1 <= 21) { // if 3 <= ind <= 21 1329 if (fstar.w[3] > 0x0 || 1330 (fstar.w[3] == 0x0 && fstar.w[2] > onehalf128[ind - 1]) || 1331 (fstar.w[3] == 0x0 && fstar.w[2] == onehalf128[ind - 1] && 1332 (fstar.w[1] || fstar.w[0]))) { 1333 // f2* > 1/2 and the result may be exact 1334 // Calculate f2* - 1/2 1335 tmp64 = fstar.w[2] - onehalf128[ind - 1]; 1336 tmp64A = fstar.w[3]; 1337 if (tmp64 > fstar.w[2]) 1338 tmp64A--; 1339 if (tmp64A || tmp64 1340 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 1341 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1342 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 1343 // set the inexact flag 1344 *pfpsf |= INEXACT_EXCEPTION; 1345 } // else the result is exact 1346 } else { // the result is inexact; f2* <= 1/2 1347 // set the inexact flag 1348 *pfpsf |= INEXACT_EXCEPTION; 1349 is_inexact_gt_midpoint = 1; 1350 } 1351 } else { // if 22 <= ind <= 33 1352 if (fstar.w[3] > onehalf128[ind - 1] || 1353 (fstar.w[3] == onehalf128[ind - 1] && 1354 (fstar.w[2] || fstar.w[1] || fstar.w[0]))) { 1355 // f2* > 1/2 and the result may be exact 1356 // Calculate f2* - 1/2 1357 tmp64 = fstar.w[3] - onehalf128[ind - 1]; 1358 if (tmp64 || fstar.w[2] 1359 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 1360 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1361 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 1362 // set the inexact flag 1363 *pfpsf |= INEXACT_EXCEPTION; 1364 } // else the result is exact 1365 } else { // the result is inexact; f2* <= 1/2 1366 // set the inexact flag 1367 *pfpsf |= INEXACT_EXCEPTION; 1368 is_inexact_gt_midpoint = 1; 1369 } 1370 } 1371 1372 // if the result was a midpoint it was rounded away from zero, so 1373 // it will need a correction 1374 // check for midpoints 1375 if ((fstar.w[3] == 0) && (fstar.w[2] == 0) 1376 && (fstar.w[1] || fstar.w[0]) 1377 && (fstar.w[1] < ten2mk128trunc[ind - 1].w[1] 1378 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1379 && fstar.w[0] <= ten2mk128trunc[ind - 1].w[0]))) { 1380 // the result is a midpoint; round to nearest 1381 if (Cstar.w[0] & 0x01) { // Cstar.w[0] is odd; MP in [EVEN, ODD] 1382 // if floor(C*) is odd C = floor(C*) - 1; the result >= 1 1383 Cstar.w[0]--; // Cstar.w[0] is now even 1384 is_inexact_gt_midpoint = 0; 1385 } else { // else MP in [ODD, EVEN] 1386 is_midpoint_lt_even = 1; 1387 is_inexact_gt_midpoint = 0; 1388 } 1389 } 1390 // general correction for RM 1391 if (is_midpoint_lt_even || is_inexact_gt_midpoint) { 1392 Cstar.w[0] = Cstar.w[0] - 1; 1393 } else { 1394 ; // the result is already correct 1395 } 1396 res = Cstar.w[0]; 1397 } else if (exp == 0) { 1398 // 1 <= q <= 10 1399 // res = +C (exact) 1400 res = C1.w[0]; 1401 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 1402 // res = +C * 10^exp (exact) 1403 res = C1.w[0] * ten2k64[exp]; 1404 } 1405 } 1406 } 1407 1408 BID_RETURN (res); 1409 } 1410 1411 /***************************************************************************** 1412 * BID128_to_uint32_ceil 1413 ****************************************************************************/ 1414 1415 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 1416 bid128_to_uint32_ceil, x) 1417 1418 unsigned int res; 1419 UINT64 x_sign; 1420 UINT64 x_exp; 1421 int exp; // unbiased exponent 1422 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 1423 UINT64 tmp64, tmp64A; 1424 BID_UI64DOUBLE tmp1; 1425 unsigned int x_nr_bits; 1426 int q, ind, shift; 1427 UINT128 C1, C; 1428 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 1429 UINT256 fstar; 1430 UINT256 P256; 1431 int is_inexact_lt_midpoint = 0; 1432 int is_midpoint_gt_even = 0; 1433 1434 // unpack x 1435 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 1436 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 1437 C1.w[1] = x.w[1] & MASK_COEFF; 1438 C1.w[0] = x.w[0]; 1439 1440 // check for NaN or Infinity 1441 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 1442 // x is special 1443 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 1444 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 1445 // set invalid flag 1446 *pfpsf |= INVALID_EXCEPTION; 1447 // return Integer Indefinite 1448 res = 0x80000000; 1449 } else { // x is QNaN 1450 // set invalid flag 1451 *pfpsf |= INVALID_EXCEPTION; 1452 // return Integer Indefinite 1453 res = 0x80000000; 1454 } 1455 BID_RETURN (res); 1456 } else { // x is not a NaN, so it must be infinity 1457 if (!x_sign) { // x is +inf 1458 // set invalid flag 1459 *pfpsf |= INVALID_EXCEPTION; 1460 // return Integer Indefinite 1461 res = 0x80000000; 1462 } else { // x is -inf 1463 // set invalid flag 1464 *pfpsf |= INVALID_EXCEPTION; 1465 // return Integer Indefinite 1466 res = 0x80000000; 1467 } 1468 BID_RETURN (res); 1469 } 1470 } 1471 // check for non-canonical values (after the check for special values) 1472 if ((C1.w[1] > 0x0001ed09bead87c0ull) 1473 || (C1.w[1] == 0x0001ed09bead87c0ull 1474 && (C1.w[0] > 0x378d8e63ffffffffull)) 1475 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 1476 res = 0x00000000; 1477 BID_RETURN (res); 1478 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 1479 // x is 0 1480 res = 0x00000000; 1481 BID_RETURN (res); 1482 } else { // x is not special and is not zero 1483 1484 // q = nr. of decimal digits in x 1485 // determine first the nr. of bits in x 1486 if (C1.w[1] == 0) { 1487 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 1488 // split the 64-bit value in two 32-bit halves to avoid rounding errors 1489 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 1490 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 1491 x_nr_bits = 1492 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1493 } else { // x < 2^32 1494 tmp1.d = (double) (C1.w[0]); // exact conversion 1495 x_nr_bits = 1496 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1497 } 1498 } else { // if x < 2^53 1499 tmp1.d = (double) C1.w[0]; // exact conversion 1500 x_nr_bits = 1501 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1502 } 1503 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 1504 tmp1.d = (double) C1.w[1]; // exact conversion 1505 x_nr_bits = 1506 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1507 } 1508 q = nr_digits[x_nr_bits - 1].digits; 1509 if (q == 0) { 1510 q = nr_digits[x_nr_bits - 1].digits1; 1511 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 1512 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 1513 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 1514 q++; 1515 } 1516 exp = (x_exp >> 49) - 6176; 1517 1518 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 1519 // set invalid flag 1520 *pfpsf |= INVALID_EXCEPTION; 1521 // return Integer Indefinite 1522 res = 0x80000000; 1523 BID_RETURN (res); 1524 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 1525 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 1526 // so x rounded to an integer may or may not fit in a signed 32-bit int 1527 // the cases that do not fit are identified here; the ones that fit 1528 // fall through and will be handled with other cases further, 1529 // under '1 <= q + exp <= 10' 1530 if (x_sign) { // if n < 0 and q + exp = 10 1531 // if n <= -1 then n is too large 1532 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 1 1533 // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x50000000a, 1<=q<=34 1534 if (q <= 11) { 1535 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 1536 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 1537 if (tmp64 >= 0x0aull) { 1538 // set invalid flag 1539 *pfpsf |= INVALID_EXCEPTION; 1540 // return Integer Indefinite 1541 res = 0x80000000; 1542 BID_RETURN (res); 1543 } 1544 // else cases that can be rounded to a 32-bit int fall through 1545 // to '1 <= q + exp <= 10' 1546 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 1547 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x0a <=> 1548 // C >= 0x0a * 10^(q-11) where 1 <= q - 11 <= 23 1549 // (scale 1 up) 1550 tmp64 = 0x0aull; 1551 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 1552 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 1553 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 1554 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 1555 } 1556 if (C1.w[1] > C.w[1] 1557 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 1558 // set invalid flag 1559 *pfpsf |= INVALID_EXCEPTION; 1560 // return Integer Indefinite 1561 res = 0x80000000; 1562 BID_RETURN (res); 1563 } 1564 // else cases that can be rounded to a 32-bit int fall through 1565 // to '1 <= q + exp <= 10' 1566 } 1567 } else { // if n > 0 and q + exp = 10 1568 // if n > 2^32 - 1 then n is too large 1569 // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 2^32 - 1 1570 // too large if 0.c(0)c(1)...c(q-1) * 10^11 > 0x9fffffff6, 1<=q<=34 1571 if (q <= 11) { 1572 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 1573 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 1574 if (tmp64 > 0x9fffffff6ull) { 1575 // set invalid flag 1576 *pfpsf |= INVALID_EXCEPTION; 1577 // return Integer Indefinite 1578 res = 0x80000000; 1579 BID_RETURN (res); 1580 } 1581 // else cases that can be rounded to a 32-bit int fall through 1582 // to '1 <= q + exp <= 10' 1583 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 1584 // 0.c(0)c(1)...c(q-1) * 10^11 > 0x9fffffff6 <=> 1585 // C > 0x9fffffff6 * 10^(q-11) where 1 <= q - 11 <= 23 1586 // (scale 2^32 up) 1587 tmp64 = 0x9fffffff6ull; 1588 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 1589 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 1590 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 1591 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 1592 } 1593 if (C1.w[1] > C.w[1] || (C1.w[1] == C.w[1] && C1.w[0] > C.w[0])) { 1594 // set invalid flag 1595 *pfpsf |= INVALID_EXCEPTION; 1596 // return Integer Indefinite 1597 res = 0x80000000; 1598 BID_RETURN (res); 1599 } 1600 // else cases that can be rounded to a 32-bit int fall through 1601 // to '1 <= q + exp <= 10' 1602 } 1603 } 1604 } 1605 // n is not too large to be converted to int32: -2^32-1 < n <= 2^32-1 1606 // Note: some of the cases tested for above fall through to this point 1607 if ((q + exp) <= 0) { 1608 // n = +/-0.0...c(0)c(1)...c(q-1) or n = +/-0.c(0)c(1)...c(q-1) 1609 // return 0 1610 if (x_sign) 1611 res = 0x00000000; 1612 else 1613 res = 0x00000001; 1614 BID_RETURN (res); 1615 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 1616 // -2^32-1 < x <= -1 or 1 <= x <= 2^32-1 so x can be rounded 1617 // toward positive infinity to a 32-bit signed integer 1618 if (x_sign) { // x <= -1 is invalid 1619 // set invalid flag 1620 *pfpsf |= INVALID_EXCEPTION; 1621 // return Integer Indefinite 1622 res = 0x80000000; 1623 BID_RETURN (res); 1624 } 1625 // x > 0 from this point on 1626 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 1627 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 1628 // chop off ind digits from the lower part of C1 1629 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 1630 tmp64 = C1.w[0]; 1631 if (ind <= 19) { 1632 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 1633 } else { 1634 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 1635 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 1636 } 1637 if (C1.w[0] < tmp64) 1638 C1.w[1]++; 1639 // calculate C* and f* 1640 // C* is actually floor(C*) in this case 1641 // C* and f* need shifting and masking, as shown by 1642 // shiftright128[] and maskhigh128[] 1643 // 1 <= x <= 33 1644 // kx = 10^(-x) = ten2mk128[ind - 1] 1645 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 1646 // the approximation of 10^(-x) was rounded up to 118 bits 1647 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 1648 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 1649 Cstar.w[1] = P256.w[3]; 1650 Cstar.w[0] = P256.w[2]; 1651 fstar.w[3] = 0; 1652 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 1653 fstar.w[1] = P256.w[1]; 1654 fstar.w[0] = P256.w[0]; 1655 } else { // 22 <= ind - 1 <= 33 1656 Cstar.w[1] = 0; 1657 Cstar.w[0] = P256.w[3]; 1658 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 1659 fstar.w[2] = P256.w[2]; 1660 fstar.w[1] = P256.w[1]; 1661 fstar.w[0] = P256.w[0]; 1662 } 1663 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 1664 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 1665 // if (0 < f* < 10^(-x)) then the result is a midpoint 1666 // if floor(C*) is even then C* = floor(C*) - logical right 1667 // shift; C* has p decimal digits, correct by Prop. 1) 1668 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 1669 // shift; C* has p decimal digits, correct by Pr. 1) 1670 // else 1671 // C* = floor(C*) (logical right shift; C has p decimal digits, 1672 // correct by Property 1) 1673 // n = C* * 10^(e+x) 1674 1675 // shift right C* by Ex-128 = shiftright128[ind] 1676 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 1677 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 1678 Cstar.w[0] = 1679 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 1680 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 1681 } else { // 22 <= ind - 1 <= 33 1682 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 1683 } 1684 // determine inexactness of the rounding of C* 1685 // if (0 < f* - 1/2 < 10^(-x)) then 1686 // the result is exact 1687 // else // if (f* - 1/2 > T*) then 1688 // the result is inexact 1689 if (ind - 1 <= 2) { 1690 if (fstar.w[1] > 0x8000000000000000ull || 1691 (fstar.w[1] == 0x8000000000000000ull 1692 && fstar.w[0] > 0x0ull)) { 1693 // f* > 1/2 and the result may be exact 1694 tmp64 = fstar.w[1] - 0x8000000000000000ull; // f* - 1/2 1695 if (tmp64 > ten2mk128trunc[ind - 1].w[1] 1696 || (tmp64 == ten2mk128trunc[ind - 1].w[1] 1697 && fstar.w[0] >= ten2mk128trunc[ind - 1].w[0])) { 1698 is_inexact_lt_midpoint = 1; 1699 } // else the result is exact 1700 } else { // the result is inexact; f2* <= 1/2 1701 ; 1702 } 1703 } else if (ind - 1 <= 21) { // if 3 <= ind <= 21 1704 if (fstar.w[3] > 0x0 || 1705 (fstar.w[3] == 0x0 && fstar.w[2] > onehalf128[ind - 1]) || 1706 (fstar.w[3] == 0x0 && fstar.w[2] == onehalf128[ind - 1] && 1707 (fstar.w[1] || fstar.w[0]))) { 1708 // f2* > 1/2 and the result may be exact 1709 // Calculate f2* - 1/2 1710 tmp64 = fstar.w[2] - onehalf128[ind - 1]; 1711 tmp64A = fstar.w[3]; 1712 if (tmp64 > fstar.w[2]) 1713 tmp64A--; 1714 if (tmp64A || tmp64 1715 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 1716 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1717 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 1718 is_inexact_lt_midpoint = 1; 1719 } // else the result is exact 1720 } else { // the result is inexact; f2* <= 1/2 1721 } 1722 } else { // if 22 <= ind <= 33 1723 if (fstar.w[3] > onehalf128[ind - 1] || 1724 (fstar.w[3] == onehalf128[ind - 1] && 1725 (fstar.w[2] || fstar.w[1] || fstar.w[0]))) { 1726 // f2* > 1/2 and the result may be exact 1727 // Calculate f2* - 1/2 1728 tmp64 = fstar.w[3] - onehalf128[ind - 1]; 1729 if (tmp64 || fstar.w[2] 1730 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 1731 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1732 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 1733 is_inexact_lt_midpoint = 1; 1734 } // else the result is exact 1735 } else { // the result is inexact; f2* <= 1/2 1736 ; 1737 } 1738 } 1739 1740 // if the result was a midpoint it was rounded away from zero, so 1741 // it will need a correction 1742 // check for midpoints 1743 if ((fstar.w[3] == 0) && (fstar.w[2] == 0) 1744 && (fstar.w[1] || fstar.w[0]) 1745 && (fstar.w[1] < ten2mk128trunc[ind - 1].w[1] 1746 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 1747 && fstar.w[0] <= ten2mk128trunc[ind - 1].w[0]))) { 1748 // the result is a midpoint; round to nearest 1749 if (Cstar.w[0] & 0x01) { // Cstar.w[0] is odd; MP in [EVEN, ODD] 1750 // if floor(C*) is odd C = floor(C*) - 1; the result >= 1 1751 Cstar.w[0]--; // Cstar.w[0] is now even 1752 is_midpoint_gt_even = 1; 1753 is_inexact_lt_midpoint = 0; 1754 } else { // else MP in [ODD, EVEN] 1755 is_inexact_lt_midpoint = 0; 1756 } 1757 } 1758 // general correction for RM 1759 if (is_midpoint_gt_even || is_inexact_lt_midpoint) { 1760 Cstar.w[0] = Cstar.w[0] + 1; 1761 } else { 1762 ; // the result is already correct 1763 } 1764 res = Cstar.w[0]; 1765 } else if (exp == 0) { 1766 // 1 <= q <= 10 1767 // res = +C (exact) 1768 res = C1.w[0]; 1769 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 1770 // res = +C * 10^exp (exact) 1771 res = C1.w[0] * ten2k64[exp]; 1772 } 1773 } 1774 } 1775 1776 BID_RETURN (res); 1777 } 1778 1779 /***************************************************************************** 1780 * BID128_to_uint32_xceil 1781 ****************************************************************************/ 1782 1783 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 1784 bid128_to_uint32_xceil, x) 1785 1786 unsigned int res; 1787 UINT64 x_sign; 1788 UINT64 x_exp; 1789 int exp; // unbiased exponent 1790 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 1791 UINT64 tmp64, tmp64A; 1792 BID_UI64DOUBLE tmp1; 1793 unsigned int x_nr_bits; 1794 int q, ind, shift; 1795 UINT128 C1, C; 1796 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 1797 UINT256 fstar; 1798 UINT256 P256; 1799 int is_inexact_lt_midpoint = 0; 1800 int is_midpoint_gt_even = 0; 1801 1802 // unpack x 1803 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 1804 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 1805 C1.w[1] = x.w[1] & MASK_COEFF; 1806 C1.w[0] = x.w[0]; 1807 1808 // check for NaN or Infinity 1809 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 1810 // x is special 1811 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 1812 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 1813 // set invalid flag 1814 *pfpsf |= INVALID_EXCEPTION; 1815 // return Integer Indefinite 1816 res = 0x80000000; 1817 } else { // x is QNaN 1818 // set invalid flag 1819 *pfpsf |= INVALID_EXCEPTION; 1820 // return Integer Indefinite 1821 res = 0x80000000; 1822 } 1823 BID_RETURN (res); 1824 } else { // x is not a NaN, so it must be infinity 1825 if (!x_sign) { // x is +inf 1826 // set invalid flag 1827 *pfpsf |= INVALID_EXCEPTION; 1828 // return Integer Indefinite 1829 res = 0x80000000; 1830 } else { // x is -inf 1831 // set invalid flag 1832 *pfpsf |= INVALID_EXCEPTION; 1833 // return Integer Indefinite 1834 res = 0x80000000; 1835 } 1836 BID_RETURN (res); 1837 } 1838 } 1839 // check for non-canonical values (after the check for special values) 1840 if ((C1.w[1] > 0x0001ed09bead87c0ull) 1841 || (C1.w[1] == 0x0001ed09bead87c0ull 1842 && (C1.w[0] > 0x378d8e63ffffffffull)) 1843 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 1844 res = 0x00000000; 1845 BID_RETURN (res); 1846 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 1847 // x is 0 1848 res = 0x00000000; 1849 BID_RETURN (res); 1850 } else { // x is not special and is not zero 1851 1852 // q = nr. of decimal digits in x 1853 // determine first the nr. of bits in x 1854 if (C1.w[1] == 0) { 1855 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 1856 // split the 64-bit value in two 32-bit halves to avoid rounding errors 1857 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 1858 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 1859 x_nr_bits = 1860 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1861 } else { // x < 2^32 1862 tmp1.d = (double) (C1.w[0]); // exact conversion 1863 x_nr_bits = 1864 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1865 } 1866 } else { // if x < 2^53 1867 tmp1.d = (double) C1.w[0]; // exact conversion 1868 x_nr_bits = 1869 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1870 } 1871 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 1872 tmp1.d = (double) C1.w[1]; // exact conversion 1873 x_nr_bits = 1874 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 1875 } 1876 q = nr_digits[x_nr_bits - 1].digits; 1877 if (q == 0) { 1878 q = nr_digits[x_nr_bits - 1].digits1; 1879 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 1880 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 1881 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 1882 q++; 1883 } 1884 exp = (x_exp >> 49) - 6176; 1885 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 1886 // set invalid flag 1887 *pfpsf |= INVALID_EXCEPTION; 1888 // return Integer Indefinite 1889 res = 0x80000000; 1890 BID_RETURN (res); 1891 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 1892 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 1893 // so x rounded to an integer may or may not fit in a signed 32-bit int 1894 // the cases that do not fit are identified here; the ones that fit 1895 // fall through and will be handled with other cases further, 1896 // under '1 <= q + exp <= 10' 1897 if (x_sign) { // if n < 0 and q + exp = 10 1898 // if n <= -1 then n is too large 1899 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 1 1900 // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x50000000a, 1<=q<=34 1901 if (q <= 11) { 1902 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 1903 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 1904 if (tmp64 >= 0x0aull) { 1905 // set invalid flag 1906 *pfpsf |= INVALID_EXCEPTION; 1907 // return Integer Indefinite 1908 res = 0x80000000; 1909 BID_RETURN (res); 1910 } 1911 // else cases that can be rounded to a 32-bit int fall through 1912 // to '1 <= q + exp <= 10' 1913 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 1914 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x0a <=> 1915 // C >= 0x0a * 10^(q-11) where 1 <= q - 11 <= 23 1916 // (scale 1 up) 1917 tmp64 = 0x0aull; 1918 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 1919 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 1920 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 1921 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 1922 } 1923 if (C1.w[1] > C.w[1] 1924 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 1925 // set invalid flag 1926 *pfpsf |= INVALID_EXCEPTION; 1927 // return Integer Indefinite 1928 res = 0x80000000; 1929 BID_RETURN (res); 1930 } 1931 // else cases that can be rounded to a 32-bit int fall through 1932 // to '1 <= q + exp <= 10' 1933 } 1934 } else { // if n > 0 and q + exp = 10 1935 // if n > 2^32 - 1 then n is too large 1936 // too large if c(0)c(1)...c(9).c(10)...c(q-1) > 2^32 - 1 1937 // too large if 0.c(0)c(1)...c(q-1) * 10^11 > 0x9fffffff6, 1<=q<=34 1938 if (q <= 11) { 1939 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 1940 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 1941 if (tmp64 > 0x9fffffff6ull) { 1942 // set invalid flag 1943 *pfpsf |= INVALID_EXCEPTION; 1944 // return Integer Indefinite 1945 res = 0x80000000; 1946 BID_RETURN (res); 1947 } 1948 // else cases that can be rounded to a 32-bit int fall through 1949 // to '1 <= q + exp <= 10' 1950 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 1951 // 0.c(0)c(1)...c(q-1) * 10^11 > 0x9fffffff6 <=> 1952 // C > 0x9fffffff6 * 10^(q-11) where 1 <= q - 11 <= 23 1953 // (scale 2^32 up) 1954 tmp64 = 0x9fffffff6ull; 1955 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 1956 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 1957 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 1958 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 1959 } 1960 if (C1.w[1] > C.w[1] || (C1.w[1] == C.w[1] && C1.w[0] > C.w[0])) { 1961 // set invalid flag 1962 *pfpsf |= INVALID_EXCEPTION; 1963 // return Integer Indefinite 1964 res = 0x80000000; 1965 BID_RETURN (res); 1966 } 1967 // else cases that can be rounded to a 32-bit int fall through 1968 // to '1 <= q + exp <= 10' 1969 } 1970 } 1971 } 1972 // n is not too large to be converted to int32: -2^32-1 < n <= 2^32-1 1973 // Note: some of the cases tested for above fall through to this point 1974 if ((q + exp) <= 0) { 1975 // n = +/-0.0...c(0)c(1)...c(q-1) or n = +/-0.c(0)c(1)...c(q-1) 1976 // set inexact flag 1977 *pfpsf |= INEXACT_EXCEPTION; 1978 // return 0 1979 if (x_sign) 1980 res = 0x00000000; 1981 else 1982 res = 0x00000001; 1983 BID_RETURN (res); 1984 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 1985 // -2^32-1 < x <= -1 or 1 <= x <= 2^32-1 so x can be rounded 1986 // toward positive infinity to a 32-bit signed integer 1987 if (x_sign) { // x <= -1 is invalid 1988 // set invalid flag 1989 *pfpsf |= INVALID_EXCEPTION; 1990 // return Integer Indefinite 1991 res = 0x80000000; 1992 BID_RETURN (res); 1993 } 1994 // x > 0 from this point on 1995 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 1996 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 1997 // chop off ind digits from the lower part of C1 1998 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 1999 tmp64 = C1.w[0]; 2000 if (ind <= 19) { 2001 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 2002 } else { 2003 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 2004 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 2005 } 2006 if (C1.w[0] < tmp64) 2007 C1.w[1]++; 2008 // calculate C* and f* 2009 // C* is actually floor(C*) in this case 2010 // C* and f* need shifting and masking, as shown by 2011 // shiftright128[] and maskhigh128[] 2012 // 1 <= x <= 33 2013 // kx = 10^(-x) = ten2mk128[ind - 1] 2014 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 2015 // the approximation of 10^(-x) was rounded up to 118 bits 2016 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 2017 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 2018 Cstar.w[1] = P256.w[3]; 2019 Cstar.w[0] = P256.w[2]; 2020 fstar.w[3] = 0; 2021 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 2022 fstar.w[1] = P256.w[1]; 2023 fstar.w[0] = P256.w[0]; 2024 } else { // 22 <= ind - 1 <= 33 2025 Cstar.w[1] = 0; 2026 Cstar.w[0] = P256.w[3]; 2027 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 2028 fstar.w[2] = P256.w[2]; 2029 fstar.w[1] = P256.w[1]; 2030 fstar.w[0] = P256.w[0]; 2031 } 2032 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 2033 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 2034 // if (0 < f* < 10^(-x)) then the result is a midpoint 2035 // if floor(C*) is even then C* = floor(C*) - logical right 2036 // shift; C* has p decimal digits, correct by Prop. 1) 2037 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 2038 // shift; C* has p decimal digits, correct by Pr. 1) 2039 // else 2040 // C* = floor(C*) (logical right shift; C has p decimal digits, 2041 // correct by Property 1) 2042 // n = C* * 10^(e+x) 2043 2044 // shift right C* by Ex-128 = shiftright128[ind] 2045 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 2046 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 2047 Cstar.w[0] = 2048 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 2049 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 2050 } else { // 22 <= ind - 1 <= 33 2051 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 2052 } 2053 // determine inexactness of the rounding of C* 2054 // if (0 < f* - 1/2 < 10^(-x)) then 2055 // the result is exact 2056 // else // if (f* - 1/2 > T*) then 2057 // the result is inexact 2058 if (ind - 1 <= 2) { 2059 if (fstar.w[1] > 0x8000000000000000ull || 2060 (fstar.w[1] == 0x8000000000000000ull 2061 && fstar.w[0] > 0x0ull)) { 2062 // f* > 1/2 and the result may be exact 2063 tmp64 = fstar.w[1] - 0x8000000000000000ull; // f* - 1/2 2064 if (tmp64 > ten2mk128trunc[ind - 1].w[1] 2065 || (tmp64 == ten2mk128trunc[ind - 1].w[1] 2066 && fstar.w[0] >= ten2mk128trunc[ind - 1].w[0])) { 2067 // set the inexact flag 2068 *pfpsf |= INEXACT_EXCEPTION; 2069 is_inexact_lt_midpoint = 1; 2070 } // else the result is exact 2071 } else { // the result is inexact; f2* <= 1/2 2072 // set the inexact flag 2073 *pfpsf |= INEXACT_EXCEPTION; 2074 } 2075 } else if (ind - 1 <= 21) { // if 3 <= ind <= 21 2076 if (fstar.w[3] > 0x0 || 2077 (fstar.w[3] == 0x0 && fstar.w[2] > onehalf128[ind - 1]) || 2078 (fstar.w[3] == 0x0 && fstar.w[2] == onehalf128[ind - 1] && 2079 (fstar.w[1] || fstar.w[0]))) { 2080 // f2* > 1/2 and the result may be exact 2081 // Calculate f2* - 1/2 2082 tmp64 = fstar.w[2] - onehalf128[ind - 1]; 2083 tmp64A = fstar.w[3]; 2084 if (tmp64 > fstar.w[2]) 2085 tmp64A--; 2086 if (tmp64A || tmp64 2087 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 2088 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2089 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 2090 // set the inexact flag 2091 *pfpsf |= INEXACT_EXCEPTION; 2092 is_inexact_lt_midpoint = 1; 2093 } // else the result is exact 2094 } else { // the result is inexact; f2* <= 1/2 2095 // set the inexact flag 2096 *pfpsf |= INEXACT_EXCEPTION; 2097 } 2098 } else { // if 22 <= ind <= 33 2099 if (fstar.w[3] > onehalf128[ind - 1] || 2100 (fstar.w[3] == onehalf128[ind - 1] && 2101 (fstar.w[2] || fstar.w[1] || fstar.w[0]))) { 2102 // f2* > 1/2 and the result may be exact 2103 // Calculate f2* - 1/2 2104 tmp64 = fstar.w[3] - onehalf128[ind - 1]; 2105 if (tmp64 || fstar.w[2] 2106 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 2107 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2108 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 2109 // set the inexact flag 2110 *pfpsf |= INEXACT_EXCEPTION; 2111 is_inexact_lt_midpoint = 1; 2112 } // else the result is exact 2113 } else { // the result is inexact; f2* <= 1/2 2114 // set the inexact flag 2115 *pfpsf |= INEXACT_EXCEPTION; 2116 } 2117 } 2118 2119 // if the result was a midpoint it was rounded away from zero, so 2120 // it will need a correction 2121 // check for midpoints 2122 if ((fstar.w[3] == 0) && (fstar.w[2] == 0) 2123 && (fstar.w[1] || fstar.w[0]) 2124 && (fstar.w[1] < ten2mk128trunc[ind - 1].w[1] 2125 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2126 && fstar.w[0] <= ten2mk128trunc[ind - 1].w[0]))) { 2127 // the result is a midpoint; round to nearest 2128 if (Cstar.w[0] & 0x01) { // Cstar.w[0] is odd; MP in [EVEN, ODD] 2129 // if floor(C*) is odd C = floor(C*) - 1; the result >= 1 2130 Cstar.w[0]--; // Cstar.w[0] is now even 2131 is_midpoint_gt_even = 1; 2132 is_inexact_lt_midpoint = 0; 2133 } else { // else MP in [ODD, EVEN] 2134 is_inexact_lt_midpoint = 0; 2135 } 2136 } 2137 // general correction for RM 2138 if (is_midpoint_gt_even || is_inexact_lt_midpoint) { 2139 Cstar.w[0] = Cstar.w[0] + 1; 2140 } else { 2141 ; // the result is already correct 2142 } 2143 res = Cstar.w[0]; 2144 } else if (exp == 0) { 2145 // 1 <= q <= 10 2146 // res = +C (exact) 2147 res = C1.w[0]; 2148 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 2149 // res = +C * 10^exp (exact) 2150 res = C1.w[0] * ten2k64[exp]; 2151 } 2152 } 2153 } 2154 2155 BID_RETURN (res); 2156 } 2157 2158 /***************************************************************************** 2159 * BID128_to_uint32_int 2160 ****************************************************************************/ 2161 2162 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 2163 bid128_to_uint32_int, x) 2164 2165 int res; 2166 UINT64 x_sign; 2167 UINT64 x_exp; 2168 int exp; // unbiased exponent 2169 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 2170 UINT64 tmp64, tmp64A; 2171 BID_UI64DOUBLE tmp1; 2172 unsigned int x_nr_bits; 2173 int q, ind, shift; 2174 UINT128 C1, C; 2175 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 2176 UINT256 fstar; 2177 UINT256 P256; 2178 int is_inexact_gt_midpoint = 0; 2179 int is_midpoint_lt_even = 0; 2180 2181 // unpack x 2182 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 2183 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 2184 C1.w[1] = x.w[1] & MASK_COEFF; 2185 C1.w[0] = x.w[0]; 2186 2187 // check for NaN or Infinity 2188 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 2189 // x is special 2190 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 2191 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 2192 // set invalid flag 2193 *pfpsf |= INVALID_EXCEPTION; 2194 // return Integer Indefinite 2195 res = 0x80000000; 2196 } else { // x is QNaN 2197 // set invalid flag 2198 *pfpsf |= INVALID_EXCEPTION; 2199 // return Integer Indefinite 2200 res = 0x80000000; 2201 } 2202 BID_RETURN (res); 2203 } else { // x is not a NaN, so it must be infinity 2204 if (!x_sign) { // x is +inf 2205 // set invalid flag 2206 *pfpsf |= INVALID_EXCEPTION; 2207 // return Integer Indefinite 2208 res = 0x80000000; 2209 } else { // x is -inf 2210 // set invalid flag 2211 *pfpsf |= INVALID_EXCEPTION; 2212 // return Integer Indefinite 2213 res = 0x80000000; 2214 } 2215 BID_RETURN (res); 2216 } 2217 } 2218 // check for non-canonical values (after the check for special values) 2219 if ((C1.w[1] > 0x0001ed09bead87c0ull) 2220 || (C1.w[1] == 0x0001ed09bead87c0ull 2221 && (C1.w[0] > 0x378d8e63ffffffffull)) 2222 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 2223 res = 0x00000000; 2224 BID_RETURN (res); 2225 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 2226 // x is 0 2227 res = 0x00000000; 2228 BID_RETURN (res); 2229 } else { // x is not special and is not zero 2230 2231 // q = nr. of decimal digits in x 2232 // determine first the nr. of bits in x 2233 if (C1.w[1] == 0) { 2234 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 2235 // split the 64-bit value in two 32-bit halves to avoid rounding errors 2236 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 2237 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 2238 x_nr_bits = 2239 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2240 } else { // x < 2^32 2241 tmp1.d = (double) (C1.w[0]); // exact conversion 2242 x_nr_bits = 2243 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2244 } 2245 } else { // if x < 2^53 2246 tmp1.d = (double) C1.w[0]; // exact conversion 2247 x_nr_bits = 2248 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2249 } 2250 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 2251 tmp1.d = (double) C1.w[1]; // exact conversion 2252 x_nr_bits = 2253 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2254 } 2255 q = nr_digits[x_nr_bits - 1].digits; 2256 if (q == 0) { 2257 q = nr_digits[x_nr_bits - 1].digits1; 2258 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 2259 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 2260 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 2261 q++; 2262 } 2263 exp = (x_exp >> 49) - 6176; 2264 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 2265 // set invalid flag 2266 *pfpsf |= INVALID_EXCEPTION; 2267 // return Integer Indefinite 2268 res = 0x80000000; 2269 BID_RETURN (res); 2270 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 2271 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 2272 // so x rounded to an integer may or may not fit in a signed 32-bit int 2273 // the cases that do not fit are identified here; the ones that fit 2274 // fall through and will be handled with other cases further, 2275 // under '1 <= q + exp <= 10' 2276 if (x_sign) { // if n < 0 and q + exp = 10 2277 // if n <= -1 then n is too large 2278 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 1 2279 // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x0a, 1<=q<=34 2280 if (q <= 11) { 2281 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 2282 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 2283 if (tmp64 >= 0x0aull) { 2284 // set invalid flag 2285 *pfpsf |= INVALID_EXCEPTION; 2286 // return Integer Indefinite 2287 res = 0x80000000; 2288 BID_RETURN (res); 2289 } 2290 // else cases that can be rounded to a 32-bit uint fall through 2291 // to '1 <= q + exp <= 10' 2292 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 2293 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x0a <=> 2294 // C >= 0x0a * 10^(q-11) where 1 <= q - 11 <= 23 2295 // (scale 1 up) 2296 tmp64 = 0x0aull; 2297 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 2298 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 2299 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 2300 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 2301 } 2302 if (C1.w[1] > C.w[1] 2303 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 2304 // set invalid flag 2305 *pfpsf |= INVALID_EXCEPTION; 2306 // return Integer Indefinite 2307 res = 0x80000000; 2308 BID_RETURN (res); 2309 } 2310 // else cases that can be rounded to a 32-bit int fall through 2311 // to '1 <= q + exp <= 10' 2312 } 2313 } else { // if n > 0 and q + exp = 10 2314 // if n >= 2^32 then n is too large 2315 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^32 2316 // too large if 0.c(0)c(1)...c(q-1) * 10^11 >= 0xa00000000, 1<=q<=34 2317 if (q <= 11) { 2318 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 2319 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 2320 if (tmp64 >= 0xa00000000ull) { 2321 // set invalid flag 2322 *pfpsf |= INVALID_EXCEPTION; 2323 // return Integer Indefinite 2324 res = 0x80000000; 2325 BID_RETURN (res); 2326 } 2327 // else cases that can be rounded to a 32-bit uint fall through 2328 // to '1 <= q + exp <= 10' 2329 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 2330 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0xa00000000 <=> 2331 // C >= 0xa00000000 * 10^(q-11) where 1 <= q - 11 <= 23 2332 // (scale 2^32 up) 2333 tmp64 = 0xa00000000ull; 2334 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 2335 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 2336 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 2337 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 2338 } 2339 if (C1.w[1] > C.w[1] 2340 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 2341 // set invalid flag 2342 *pfpsf |= INVALID_EXCEPTION; 2343 // return Integer Indefinite 2344 res = 0x80000000; 2345 BID_RETURN (res); 2346 } 2347 // else cases that can be rounded to a 32-bit int fall through 2348 // to '1 <= q + exp <= 10' 2349 } 2350 } 2351 } 2352 // n is not too large to be converted to uint32: -2^32 < n < 2^32 2353 // Note: some of the cases tested for above fall through to this point 2354 if ((q + exp) <= 0) { 2355 // n = +/-0.0...c(0)c(1)...c(q-1) or n = +/-0.c(0)c(1)...c(q-1) 2356 // return 0 2357 res = 0x00000000; 2358 BID_RETURN (res); 2359 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 2360 // x = d(0)...d(k).d(k+1)..., k >= 0, d(0) != 0 2361 if (x_sign) { // x <= -1 2362 // set invalid flag 2363 *pfpsf |= INVALID_EXCEPTION; 2364 // return Integer Indefinite 2365 res = 0x80000000; 2366 BID_RETURN (res); 2367 } 2368 // x > 0 from this point on 2369 // 1 <= x < 2^32 so x can be rounded to zero to a 32-bit unsigned integer 2370 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 2371 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 2372 // chop off ind digits from the lower part of C1 2373 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 2374 tmp64 = C1.w[0]; 2375 if (ind <= 19) { 2376 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 2377 } else { 2378 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 2379 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 2380 } 2381 if (C1.w[0] < tmp64) 2382 C1.w[1]++; 2383 // calculate C* and f* 2384 // C* is actually floor(C*) in this case 2385 // C* and f* need shifting and masking, as shown by 2386 // shiftright128[] and maskhigh128[] 2387 // 1 <= x <= 33 2388 // kx = 10^(-x) = ten2mk128[ind - 1] 2389 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 2390 // the approximation of 10^(-x) was rounded up to 118 bits 2391 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 2392 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 2393 Cstar.w[1] = P256.w[3]; 2394 Cstar.w[0] = P256.w[2]; 2395 fstar.w[3] = 0; 2396 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 2397 fstar.w[1] = P256.w[1]; 2398 fstar.w[0] = P256.w[0]; 2399 } else { // 22 <= ind - 1 <= 33 2400 Cstar.w[1] = 0; 2401 Cstar.w[0] = P256.w[3]; 2402 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 2403 fstar.w[2] = P256.w[2]; 2404 fstar.w[1] = P256.w[1]; 2405 fstar.w[0] = P256.w[0]; 2406 } 2407 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 2408 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 2409 // if (0 < f* < 10^(-x)) then the result is a midpoint 2410 // if floor(C*) is even then C* = floor(C*) - logical right 2411 // shift; C* has p decimal digits, correct by Prop. 1) 2412 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 2413 // shift; C* has p decimal digits, correct by Pr. 1) 2414 // else 2415 // C* = floor(C*) (logical right shift; C has p decimal digits, 2416 // correct by Property 1) 2417 // n = C* * 10^(e+x) 2418 2419 // shift right C* by Ex-128 = shiftright128[ind] 2420 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 2421 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 2422 Cstar.w[0] = 2423 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 2424 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 2425 } else { // 22 <= ind - 1 <= 33 2426 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 2427 } 2428 // determine inexactness of the rounding of C* 2429 // if (0 < f* - 1/2 < 10^(-x)) then 2430 // the result is exact 2431 // else // if (f* - 1/2 > T*) then 2432 // the result is inexact 2433 if (ind - 1 <= 2) { 2434 if (fstar.w[1] > 0x8000000000000000ull || 2435 (fstar.w[1] == 0x8000000000000000ull 2436 && fstar.w[0] > 0x0ull)) { 2437 // f* > 1/2 and the result may be exact 2438 tmp64 = fstar.w[1] - 0x8000000000000000ull; // f* - 1/2 2439 if (tmp64 > ten2mk128trunc[ind - 1].w[1] 2440 || (tmp64 == ten2mk128trunc[ind - 1].w[1] 2441 && fstar.w[0] >= ten2mk128trunc[ind - 1].w[0])) { 2442 } // else the result is exact 2443 } else { // the result is inexact; f2* <= 1/2 2444 is_inexact_gt_midpoint = 1; 2445 } 2446 } else if (ind - 1 <= 21) { // if 3 <= ind <= 21 2447 if (fstar.w[3] > 0x0 || 2448 (fstar.w[3] == 0x0 && fstar.w[2] > onehalf128[ind - 1]) || 2449 (fstar.w[3] == 0x0 && fstar.w[2] == onehalf128[ind - 1] && 2450 (fstar.w[1] || fstar.w[0]))) { 2451 // f2* > 1/2 and the result may be exact 2452 // Calculate f2* - 1/2 2453 tmp64 = fstar.w[2] - onehalf128[ind - 1]; 2454 tmp64A = fstar.w[3]; 2455 if (tmp64 > fstar.w[2]) 2456 tmp64A--; 2457 if (tmp64A || tmp64 2458 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 2459 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2460 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 2461 } // else the result is exact 2462 } else { // the result is inexact; f2* <= 1/2 2463 is_inexact_gt_midpoint = 1; 2464 } 2465 } else { // if 22 <= ind <= 33 2466 if (fstar.w[3] > onehalf128[ind - 1] || 2467 (fstar.w[3] == onehalf128[ind - 1] && 2468 (fstar.w[2] || fstar.w[1] || fstar.w[0]))) { 2469 // f2* > 1/2 and the result may be exact 2470 // Calculate f2* - 1/2 2471 tmp64 = fstar.w[3] - onehalf128[ind - 1]; 2472 if (tmp64 || fstar.w[2] 2473 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 2474 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2475 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 2476 } // else the result is exact 2477 } else { // the result is inexact; f2* <= 1/2 2478 is_inexact_gt_midpoint = 1; 2479 } 2480 } 2481 2482 // if the result was a midpoint it was rounded away from zero, so 2483 // it will need a correction 2484 // check for midpoints 2485 if ((fstar.w[3] == 0) && (fstar.w[2] == 0) 2486 && (fstar.w[1] || fstar.w[0]) 2487 && (fstar.w[1] < ten2mk128trunc[ind - 1].w[1] 2488 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2489 && fstar.w[0] <= ten2mk128trunc[ind - 1].w[0]))) { 2490 // the result is a midpoint; round to nearest 2491 if (Cstar.w[0] & 0x01) { // Cstar.w[0] is odd; MP in [EVEN, ODD] 2492 // if floor(C*) is odd C = floor(C*) - 1; the result >= 1 2493 Cstar.w[0]--; // Cstar.w[0] is now even 2494 is_inexact_gt_midpoint = 0; 2495 } else { // else MP in [ODD, EVEN] 2496 is_midpoint_lt_even = 1; 2497 is_inexact_gt_midpoint = 0; 2498 } 2499 } 2500 // general correction for RZ 2501 if (is_midpoint_lt_even || is_inexact_gt_midpoint) { 2502 Cstar.w[0] = Cstar.w[0] - 1; 2503 } else { 2504 ; // exact, the result is already correct 2505 } 2506 res = Cstar.w[0]; 2507 } else if (exp == 0) { 2508 // 1 <= q <= 10 2509 // res = +C (exact) 2510 res = C1.w[0]; 2511 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 2512 // res = +C * 10^exp (exact) 2513 res = C1.w[0] * ten2k64[exp]; 2514 } 2515 } 2516 } 2517 2518 BID_RETURN (res); 2519 } 2520 2521 /***************************************************************************** 2522 * BID128_to_uint32_xint 2523 ****************************************************************************/ 2524 2525 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 2526 bid128_to_uint32_xint, x) 2527 2528 int res; 2529 UINT64 x_sign; 2530 UINT64 x_exp; 2531 int exp; // unbiased exponent 2532 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 2533 UINT64 tmp64, tmp64A; 2534 BID_UI64DOUBLE tmp1; 2535 unsigned int x_nr_bits; 2536 int q, ind, shift; 2537 UINT128 C1, C; 2538 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 2539 UINT256 fstar; 2540 UINT256 P256; 2541 int is_inexact_gt_midpoint = 0; 2542 int is_midpoint_lt_even = 0; 2543 2544 // unpack x 2545 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 2546 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 2547 C1.w[1] = x.w[1] & MASK_COEFF; 2548 C1.w[0] = x.w[0]; 2549 2550 // check for NaN or Infinity 2551 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 2552 // x is special 2553 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 2554 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 2555 // set invalid flag 2556 *pfpsf |= INVALID_EXCEPTION; 2557 // return Integer Indefinite 2558 res = 0x80000000; 2559 } else { // x is QNaN 2560 // set invalid flag 2561 *pfpsf |= INVALID_EXCEPTION; 2562 // return Integer Indefinite 2563 res = 0x80000000; 2564 } 2565 BID_RETURN (res); 2566 } else { // x is not a NaN, so it must be infinity 2567 if (!x_sign) { // x is +inf 2568 // set invalid flag 2569 *pfpsf |= INVALID_EXCEPTION; 2570 // return Integer Indefinite 2571 res = 0x80000000; 2572 } else { // x is -inf 2573 // set invalid flag 2574 *pfpsf |= INVALID_EXCEPTION; 2575 // return Integer Indefinite 2576 res = 0x80000000; 2577 } 2578 BID_RETURN (res); 2579 } 2580 } 2581 // check for non-canonical values (after the check for special values) 2582 if ((C1.w[1] > 0x0001ed09bead87c0ull) 2583 || (C1.w[1] == 0x0001ed09bead87c0ull 2584 && (C1.w[0] > 0x378d8e63ffffffffull)) 2585 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 2586 res = 0x00000000; 2587 BID_RETURN (res); 2588 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 2589 // x is 0 2590 res = 0x00000000; 2591 BID_RETURN (res); 2592 } else { // x is not special and is not zero 2593 2594 // q = nr. of decimal digits in x 2595 // determine first the nr. of bits in x 2596 if (C1.w[1] == 0) { 2597 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 2598 // split the 64-bit value in two 32-bit halves to avoid rounding errors 2599 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 2600 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 2601 x_nr_bits = 2602 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2603 } else { // x < 2^32 2604 tmp1.d = (double) (C1.w[0]); // exact conversion 2605 x_nr_bits = 2606 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2607 } 2608 } else { // if x < 2^53 2609 tmp1.d = (double) C1.w[0]; // exact conversion 2610 x_nr_bits = 2611 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2612 } 2613 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 2614 tmp1.d = (double) C1.w[1]; // exact conversion 2615 x_nr_bits = 2616 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2617 } 2618 q = nr_digits[x_nr_bits - 1].digits; 2619 if (q == 0) { 2620 q = nr_digits[x_nr_bits - 1].digits1; 2621 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 2622 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 2623 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 2624 q++; 2625 } 2626 exp = (x_exp >> 49) - 6176; 2627 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 2628 // set invalid flag 2629 *pfpsf |= INVALID_EXCEPTION; 2630 // return Integer Indefinite 2631 res = 0x80000000; 2632 BID_RETURN (res); 2633 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 2634 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 2635 // so x rounded to an integer may or may not fit in a signed 32-bit int 2636 // the cases that do not fit are identified here; the ones that fit 2637 // fall through and will be handled with other cases further, 2638 // under '1 <= q + exp <= 10' 2639 if (x_sign) { // if n < 0 and q + exp = 10 2640 // if n <= -1 then n is too large 2641 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 1 2642 // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x0a, 1<=q<=34 2643 if (q <= 11) { 2644 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 2645 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 2646 if (tmp64 >= 0x0aull) { 2647 // set invalid flag 2648 *pfpsf |= INVALID_EXCEPTION; 2649 // return Integer Indefinite 2650 res = 0x80000000; 2651 BID_RETURN (res); 2652 } 2653 // else cases that can be rounded to a 32-bit uint fall through 2654 // to '1 <= q + exp <= 10' 2655 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 2656 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x0a <=> 2657 // C >= 0x0a * 10^(q-11) where 1 <= q - 11 <= 23 2658 // (scale 1 up) 2659 tmp64 = 0x0aull; 2660 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 2661 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 2662 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 2663 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 2664 } 2665 if (C1.w[1] > C.w[1] 2666 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 2667 // set invalid flag 2668 *pfpsf |= INVALID_EXCEPTION; 2669 // return Integer Indefinite 2670 res = 0x80000000; 2671 BID_RETURN (res); 2672 } 2673 // else cases that can be rounded to a 32-bit int fall through 2674 // to '1 <= q + exp <= 10' 2675 } 2676 } else { // if n > 0 and q + exp = 10 2677 // if n >= 2^32 then n is too large 2678 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^32 2679 // too large if 0.c(0)c(1)...c(q-1) * 10^11 >= 0xa00000000, 1<=q<=34 2680 if (q <= 11) { 2681 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 2682 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 2683 if (tmp64 >= 0xa00000000ull) { 2684 // set invalid flag 2685 *pfpsf |= INVALID_EXCEPTION; 2686 // return Integer Indefinite 2687 res = 0x80000000; 2688 BID_RETURN (res); 2689 } 2690 // else cases that can be rounded to a 32-bit uint fall through 2691 // to '1 <= q + exp <= 10' 2692 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 2693 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0xa00000000 <=> 2694 // C >= 0xa00000000 * 10^(q-11) where 1 <= q - 11 <= 23 2695 // (scale 2^32 up) 2696 tmp64 = 0xa00000000ull; 2697 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 2698 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 2699 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 2700 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 2701 } 2702 if (C1.w[1] > C.w[1] 2703 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 2704 // set invalid flag 2705 *pfpsf |= INVALID_EXCEPTION; 2706 // return Integer Indefinite 2707 res = 0x80000000; 2708 BID_RETURN (res); 2709 } 2710 // else cases that can be rounded to a 32-bit int fall through 2711 // to '1 <= q + exp <= 10' 2712 } 2713 } 2714 } 2715 // n is not too large to be converted to uint32: -2^32 < n < 2^32 2716 // Note: some of the cases tested for above fall through to this point 2717 if ((q + exp) <= 0) { 2718 // n = +/-0.0...c(0)c(1)...c(q-1) or n = +/-0.c(0)c(1)...c(q-1) 2719 // set inexact flag 2720 *pfpsf |= INEXACT_EXCEPTION; 2721 // return 0 2722 res = 0x00000000; 2723 BID_RETURN (res); 2724 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 2725 // x = d(0)...d(k).d(k+1)..., k >= 0, d(0) != 0 2726 if (x_sign) { // x <= -1 2727 // set invalid flag 2728 *pfpsf |= INVALID_EXCEPTION; 2729 // return Integer Indefinite 2730 res = 0x80000000; 2731 BID_RETURN (res); 2732 } 2733 // x > 0 from this point on 2734 // 1 <= x < 2^32 so x can be rounded to zero to a 32-bit unsigned integer 2735 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 2736 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 2737 // chop off ind digits from the lower part of C1 2738 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 2739 tmp64 = C1.w[0]; 2740 if (ind <= 19) { 2741 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 2742 } else { 2743 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 2744 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 2745 } 2746 if (C1.w[0] < tmp64) 2747 C1.w[1]++; 2748 // calculate C* and f* 2749 // C* is actually floor(C*) in this case 2750 // C* and f* need shifting and masking, as shown by 2751 // shiftright128[] and maskhigh128[] 2752 // 1 <= x <= 33 2753 // kx = 10^(-x) = ten2mk128[ind - 1] 2754 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 2755 // the approximation of 10^(-x) was rounded up to 118 bits 2756 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 2757 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 2758 Cstar.w[1] = P256.w[3]; 2759 Cstar.w[0] = P256.w[2]; 2760 fstar.w[3] = 0; 2761 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 2762 fstar.w[1] = P256.w[1]; 2763 fstar.w[0] = P256.w[0]; 2764 } else { // 22 <= ind - 1 <= 33 2765 Cstar.w[1] = 0; 2766 Cstar.w[0] = P256.w[3]; 2767 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 2768 fstar.w[2] = P256.w[2]; 2769 fstar.w[1] = P256.w[1]; 2770 fstar.w[0] = P256.w[0]; 2771 } 2772 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 2773 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 2774 // if (0 < f* < 10^(-x)) then the result is a midpoint 2775 // if floor(C*) is even then C* = floor(C*) - logical right 2776 // shift; C* has p decimal digits, correct by Prop. 1) 2777 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 2778 // shift; C* has p decimal digits, correct by Pr. 1) 2779 // else 2780 // C* = floor(C*) (logical right shift; C has p decimal digits, 2781 // correct by Property 1) 2782 // n = C* * 10^(e+x) 2783 2784 // shift right C* by Ex-128 = shiftright128[ind] 2785 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 2786 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 2787 Cstar.w[0] = 2788 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 2789 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 2790 } else { // 22 <= ind - 1 <= 33 2791 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 2792 } 2793 // determine inexactness of the rounding of C* 2794 // if (0 < f* - 1/2 < 10^(-x)) then 2795 // the result is exact 2796 // else // if (f* - 1/2 > T*) then 2797 // the result is inexact 2798 if (ind - 1 <= 2) { 2799 if (fstar.w[1] > 0x8000000000000000ull || 2800 (fstar.w[1] == 0x8000000000000000ull 2801 && fstar.w[0] > 0x0ull)) { 2802 // f* > 1/2 and the result may be exact 2803 tmp64 = fstar.w[1] - 0x8000000000000000ull; // f* - 1/2 2804 if (tmp64 > ten2mk128trunc[ind - 1].w[1] 2805 || (tmp64 == ten2mk128trunc[ind - 1].w[1] 2806 && fstar.w[0] >= ten2mk128trunc[ind - 1].w[0])) { 2807 // set the inexact flag 2808 *pfpsf |= INEXACT_EXCEPTION; 2809 } // else the result is exact 2810 } else { // the result is inexact; f2* <= 1/2 2811 // set the inexact flag 2812 *pfpsf |= INEXACT_EXCEPTION; 2813 is_inexact_gt_midpoint = 1; 2814 } 2815 } else if (ind - 1 <= 21) { // if 3 <= ind <= 21 2816 if (fstar.w[3] > 0x0 || 2817 (fstar.w[3] == 0x0 && fstar.w[2] > onehalf128[ind - 1]) || 2818 (fstar.w[3] == 0x0 && fstar.w[2] == onehalf128[ind - 1] && 2819 (fstar.w[1] || fstar.w[0]))) { 2820 // f2* > 1/2 and the result may be exact 2821 // Calculate f2* - 1/2 2822 tmp64 = fstar.w[2] - onehalf128[ind - 1]; 2823 tmp64A = fstar.w[3]; 2824 if (tmp64 > fstar.w[2]) 2825 tmp64A--; 2826 if (tmp64A || tmp64 2827 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 2828 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2829 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 2830 // set the inexact flag 2831 *pfpsf |= INEXACT_EXCEPTION; 2832 } // else the result is exact 2833 } else { // the result is inexact; f2* <= 1/2 2834 // set the inexact flag 2835 *pfpsf |= INEXACT_EXCEPTION; 2836 is_inexact_gt_midpoint = 1; 2837 } 2838 } else { // if 22 <= ind <= 33 2839 if (fstar.w[3] > onehalf128[ind - 1] || 2840 (fstar.w[3] == onehalf128[ind - 1] && 2841 (fstar.w[2] || fstar.w[1] || fstar.w[0]))) { 2842 // f2* > 1/2 and the result may be exact 2843 // Calculate f2* - 1/2 2844 tmp64 = fstar.w[3] - onehalf128[ind - 1]; 2845 if (tmp64 || fstar.w[2] 2846 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 2847 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2848 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 2849 // set the inexact flag 2850 *pfpsf |= INEXACT_EXCEPTION; 2851 } // else the result is exact 2852 } else { // the result is inexact; f2* <= 1/2 2853 // set the inexact flag 2854 *pfpsf |= INEXACT_EXCEPTION; 2855 is_inexact_gt_midpoint = 1; 2856 } 2857 } 2858 2859 // if the result was a midpoint it was rounded away from zero, so 2860 // it will need a correction 2861 // check for midpoints 2862 if ((fstar.w[3] == 0) && (fstar.w[2] == 0) 2863 && (fstar.w[1] || fstar.w[0]) 2864 && (fstar.w[1] < ten2mk128trunc[ind - 1].w[1] 2865 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 2866 && fstar.w[0] <= ten2mk128trunc[ind - 1].w[0]))) { 2867 // the result is a midpoint; round to nearest 2868 if (Cstar.w[0] & 0x01) { // Cstar.w[0] is odd; MP in [EVEN, ODD] 2869 // if floor(C*) is odd C = floor(C*) - 1; the result >= 1 2870 Cstar.w[0]--; // Cstar.w[0] is now even 2871 is_inexact_gt_midpoint = 0; 2872 } else { // else MP in [ODD, EVEN] 2873 is_midpoint_lt_even = 1; 2874 is_inexact_gt_midpoint = 0; 2875 } 2876 } 2877 // general correction for RZ 2878 if (is_midpoint_lt_even || is_inexact_gt_midpoint) { 2879 Cstar.w[0] = Cstar.w[0] - 1; 2880 } else { 2881 ; // exact, the result is already correct 2882 } 2883 res = Cstar.w[0]; 2884 } else if (exp == 0) { 2885 // 1 <= q <= 10 2886 // res = +C (exact) 2887 res = C1.w[0]; 2888 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 2889 // res = +C * 10^exp (exact) 2890 res = C1.w[0] * ten2k64[exp]; 2891 } 2892 } 2893 } 2894 2895 BID_RETURN (res); 2896 } 2897 2898 /***************************************************************************** 2899 * BID128_to_uint32_rninta 2900 ****************************************************************************/ 2901 2902 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 2903 bid128_to_uint32_rninta, x) 2904 2905 unsigned int res; 2906 UINT64 x_sign; 2907 UINT64 x_exp; 2908 int exp; // unbiased exponent 2909 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 2910 UINT64 tmp64; 2911 BID_UI64DOUBLE tmp1; 2912 unsigned int x_nr_bits; 2913 int q, ind, shift; 2914 UINT128 C1, C; 2915 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 2916 UINT256 P256; 2917 2918 // unpack x 2919 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 2920 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 2921 C1.w[1] = x.w[1] & MASK_COEFF; 2922 C1.w[0] = x.w[0]; 2923 2924 // check for NaN or Infinity 2925 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 2926 // x is special 2927 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 2928 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 2929 // set invalid flag 2930 *pfpsf |= INVALID_EXCEPTION; 2931 // return Integer Indefinite 2932 res = 0x80000000; 2933 } else { // x is QNaN 2934 // set invalid flag 2935 *pfpsf |= INVALID_EXCEPTION; 2936 // return Integer Indefinite 2937 res = 0x80000000; 2938 } 2939 BID_RETURN (res); 2940 } else { // x is not a NaN, so it must be infinity 2941 if (!x_sign) { // x is +inf 2942 // set invalid flag 2943 *pfpsf |= INVALID_EXCEPTION; 2944 // return Integer Indefinite 2945 res = 0x80000000; 2946 } else { // x is -inf 2947 // set invalid flag 2948 *pfpsf |= INVALID_EXCEPTION; 2949 // return Integer Indefinite 2950 res = 0x80000000; 2951 } 2952 BID_RETURN (res); 2953 } 2954 } 2955 // check for non-canonical values (after the check for special values) 2956 if ((C1.w[1] > 0x0001ed09bead87c0ull) 2957 || (C1.w[1] == 0x0001ed09bead87c0ull 2958 && (C1.w[0] > 0x378d8e63ffffffffull)) 2959 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 2960 res = 0x00000000; 2961 BID_RETURN (res); 2962 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 2963 // x is 0 2964 res = 0x00000000; 2965 BID_RETURN (res); 2966 } else { // x is not special and is not zero 2967 2968 // q = nr. of decimal digits in x 2969 // determine first the nr. of bits in x 2970 if (C1.w[1] == 0) { 2971 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 2972 // split the 64-bit value in two 32-bit halves to avoid rounding errors 2973 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 2974 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 2975 x_nr_bits = 2976 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2977 } else { // x < 2^32 2978 tmp1.d = (double) (C1.w[0]); // exact conversion 2979 x_nr_bits = 2980 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2981 } 2982 } else { // if x < 2^53 2983 tmp1.d = (double) C1.w[0]; // exact conversion 2984 x_nr_bits = 2985 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2986 } 2987 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 2988 tmp1.d = (double) C1.w[1]; // exact conversion 2989 x_nr_bits = 2990 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 2991 } 2992 q = nr_digits[x_nr_bits - 1].digits; 2993 if (q == 0) { 2994 q = nr_digits[x_nr_bits - 1].digits1; 2995 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 2996 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 2997 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 2998 q++; 2999 } 3000 exp = (x_exp >> 49) - 6176; 3001 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 3002 // set invalid flag 3003 *pfpsf |= INVALID_EXCEPTION; 3004 // return Integer Indefinite 3005 res = 0x80000000; 3006 BID_RETURN (res); 3007 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 3008 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 3009 // so x rounded to an integer may or may not fit in a signed 32-bit int 3010 // the cases that do not fit are identified here; the ones that fit 3011 // fall through and will be handled with other cases further, 3012 // under '1 <= q + exp <= 10' 3013 if (x_sign) { // if n < 0 and q + exp = 10 3014 // if n <= -1/2 then n is too large 3015 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 1/2 3016 // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x05, 1<=q<=34 3017 if (q <= 11) { 3018 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 3019 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 3020 if (tmp64 >= 0x05ull) { 3021 // set invalid flag 3022 *pfpsf |= INVALID_EXCEPTION; 3023 // return Integer Indefinite 3024 res = 0x80000000; 3025 BID_RETURN (res); 3026 } 3027 // else cases that can be rounded to a 32-bit int fall through 3028 // to '1 <= q + exp <= 10' 3029 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 3030 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x05 <=> 3031 // C >= 0x05 * 10^(q-11) where 1 <= q - 11 <= 23 3032 // (scale 1/2 up) 3033 tmp64 = 0x05ull; 3034 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 3035 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 3036 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 3037 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 3038 } 3039 if (C1.w[1] > C.w[1] 3040 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 3041 // set invalid flag 3042 *pfpsf |= INVALID_EXCEPTION; 3043 // return Integer Indefinite 3044 res = 0x80000000; 3045 BID_RETURN (res); 3046 } 3047 // else cases that can be rounded to a 32-bit int fall through 3048 // to '1 <= q + exp <= 10' 3049 } 3050 } else { // if n > 0 and q + exp = 10 3051 // if n >= 2^32 - 1/2 then n is too large 3052 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^32-1/2 3053 // too large if 0.c(0)c(1)...c(q-1) * 10^11 >= 0x9fffffffb, 1<=q<=34 3054 if (q <= 11) { 3055 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 3056 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 3057 if (tmp64 >= 0x9fffffffbull) { 3058 // set invalid flag 3059 *pfpsf |= INVALID_EXCEPTION; 3060 // return Integer Indefinite 3061 res = 0x80000000; 3062 BID_RETURN (res); 3063 } 3064 // else cases that can be rounded to a 32-bit int fall through 3065 // to '1 <= q + exp <= 10' 3066 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 3067 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x9fffffffb <=> 3068 // C >= 0x9fffffffb * 10^(q-11) where 1 <= q - 11 <= 23 3069 // (scale 2^32-1/2 up) 3070 tmp64 = 0x9fffffffbull; 3071 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 3072 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 3073 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 3074 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 3075 } 3076 if (C1.w[1] > C.w[1] 3077 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 3078 // set invalid flag 3079 *pfpsf |= INVALID_EXCEPTION; 3080 // return Integer Indefinite 3081 res = 0x80000000; 3082 BID_RETURN (res); 3083 } 3084 // else cases that can be rounded to a 32-bit int fall through 3085 // to '1 <= q + exp <= 10' 3086 } 3087 } 3088 } 3089 // n is not too large to be converted to int32: -1/2 < n < 2^32 - 1/2 3090 // Note: some of the cases tested for above fall through to this point 3091 if ((q + exp) < 0) { // n = +/-0.0...c(0)c(1)...c(q-1) 3092 // return 0 3093 res = 0x00000000; 3094 BID_RETURN (res); 3095 } else if ((q + exp) == 0) { // n = +/-0.c(0)c(1)...c(q-1) 3096 // if 0.c(0)c(1)...c(q-1) < 0.5 <=> c(0)c(1)...c(q-1) < 5 * 10^(q-1) 3097 // res = 0 3098 // else if x > 0 3099 // res = +1 3100 // else // if x < 0 3101 // invalid exc 3102 ind = q - 1; 3103 if (ind <= 18) { // 0 <= ind <= 18 3104 if ((C1.w[1] == 0) && (C1.w[0] < midpoint64[ind])) { 3105 res = 0x00000000; // return 0 3106 } else if (!x_sign) { // n > 0 3107 res = 0x00000001; // return +1 3108 } else { 3109 res = 0x80000000; 3110 *pfpsf |= INVALID_EXCEPTION; 3111 } 3112 } else { // 19 <= ind <= 33 3113 if ((C1.w[1] < midpoint128[ind - 19].w[1]) 3114 || ((C1.w[1] == midpoint128[ind - 19].w[1]) 3115 && (C1.w[0] < midpoint128[ind - 19].w[0]))) { 3116 res = 0x00000000; // return 0 3117 } else if (!x_sign) { // n > 0 3118 res = 0x00000001; // return +1 3119 } else { 3120 res = 0x80000000; 3121 *pfpsf |= INVALID_EXCEPTION; 3122 } 3123 } 3124 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 3125 if (x_sign) { // x <= -1 3126 // set invalid flag 3127 *pfpsf |= INVALID_EXCEPTION; 3128 // return Integer Indefinite 3129 res = 0x80000000; 3130 BID_RETURN (res); 3131 } 3132 // 1 <= x < 2^31-1/2 so x can be rounded 3133 // to nearest-away to a 32-bit signed integer 3134 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 3135 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 3136 // chop off ind digits from the lower part of C1 3137 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 3138 tmp64 = C1.w[0]; 3139 if (ind <= 19) { 3140 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 3141 } else { 3142 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 3143 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 3144 } 3145 if (C1.w[0] < tmp64) 3146 C1.w[1]++; 3147 // calculate C* and f* 3148 // C* is actually floor(C*) in this case 3149 // C* and f* need shifting and masking, as shown by 3150 // shiftright128[] and maskhigh128[] 3151 // 1 <= x <= 33 3152 // kx = 10^(-x) = ten2mk128[ind - 1] 3153 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 3154 // the approximation of 10^(-x) was rounded up to 118 bits 3155 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 3156 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 3157 Cstar.w[1] = P256.w[3]; 3158 Cstar.w[0] = P256.w[2]; 3159 } else { // 22 <= ind - 1 <= 33 3160 Cstar.w[1] = 0; 3161 Cstar.w[0] = P256.w[3]; 3162 } 3163 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 3164 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 3165 // if (0 < f* < 10^(-x)) then the result is a midpoint 3166 // if floor(C*) is even then C* = floor(C*) - logical right 3167 // shift; C* has p decimal digits, correct by Prop. 1) 3168 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 3169 // shift; C* has p decimal digits, correct by Pr. 1) 3170 // else 3171 // C* = floor(C*) (logical right shift; C has p decimal digits, 3172 // correct by Property 1) 3173 // n = C* * 10^(e+x) 3174 3175 // shift right C* by Ex-128 = shiftright128[ind] 3176 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 3177 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 3178 Cstar.w[0] = 3179 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 3180 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 3181 } else { // 22 <= ind - 1 <= 33 3182 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 3183 } 3184 // if the result was a midpoint, it was already rounded away from zero 3185 res = Cstar.w[0]; // always positive 3186 // no need to check for midpoints - already rounded away from zero! 3187 } else if (exp == 0) { 3188 // 1 <= q <= 10 3189 // res = +C (exact) 3190 res = C1.w[0]; 3191 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 3192 // res = +C * 10^exp (exact) 3193 res = C1.w[0] * ten2k64[exp]; 3194 } 3195 } 3196 } 3197 3198 BID_RETURN (res); 3199 } 3200 3201 /***************************************************************************** 3202 * BID128_to_uint32_xrninta 3203 ****************************************************************************/ 3204 3205 BID128_FUNCTION_ARG1_NORND_CUSTOMRESTYPE (unsigned int, 3206 bid128_to_uint32_xrninta, x) 3207 3208 unsigned int res; 3209 UINT64 x_sign; 3210 UINT64 x_exp; 3211 int exp; // unbiased exponent 3212 // Note: C1.w[1], C1.w[0] represent x_signif_hi, x_signif_lo (all are UINT64) 3213 UINT64 tmp64, tmp64A; 3214 BID_UI64DOUBLE tmp1; 3215 unsigned int x_nr_bits; 3216 int q, ind, shift; 3217 UINT128 C1, C; 3218 UINT128 Cstar; // C* represents up to 34 decimal digits ~ 113 bits 3219 UINT256 fstar; 3220 UINT256 P256; 3221 unsigned int tmp_inexact = 0; 3222 3223 // unpack x 3224 x_sign = x.w[1] & MASK_SIGN; // 0 for positive, MASK_SIGN for negative 3225 x_exp = x.w[1] & MASK_EXP; // biased and shifted left 49 bit positions 3226 C1.w[1] = x.w[1] & MASK_COEFF; 3227 C1.w[0] = x.w[0]; 3228 3229 // check for NaN or Infinity 3230 if ((x.w[1] & MASK_SPECIAL) == MASK_SPECIAL) { 3231 // x is special 3232 if ((x.w[1] & MASK_NAN) == MASK_NAN) { // x is NAN 3233 if ((x.w[1] & MASK_SNAN) == MASK_SNAN) { // x is SNAN 3234 // set invalid flag 3235 *pfpsf |= INVALID_EXCEPTION; 3236 // return Integer Indefinite 3237 res = 0x80000000; 3238 } else { // x is QNaN 3239 // set invalid flag 3240 *pfpsf |= INVALID_EXCEPTION; 3241 // return Integer Indefinite 3242 res = 0x80000000; 3243 } 3244 BID_RETURN (res); 3245 } else { // x is not a NaN, so it must be infinity 3246 if (!x_sign) { // x is +inf 3247 // set invalid flag 3248 *pfpsf |= INVALID_EXCEPTION; 3249 // return Integer Indefinite 3250 res = 0x80000000; 3251 } else { // x is -inf 3252 // set invalid flag 3253 *pfpsf |= INVALID_EXCEPTION; 3254 // return Integer Indefinite 3255 res = 0x80000000; 3256 } 3257 BID_RETURN (res); 3258 } 3259 } 3260 // check for non-canonical values (after the check for special values) 3261 if ((C1.w[1] > 0x0001ed09bead87c0ull) 3262 || (C1.w[1] == 0x0001ed09bead87c0ull 3263 && (C1.w[0] > 0x378d8e63ffffffffull)) 3264 || ((x.w[1] & 0x6000000000000000ull) == 0x6000000000000000ull)) { 3265 res = 0x00000000; 3266 BID_RETURN (res); 3267 } else if ((C1.w[1] == 0x0ull) && (C1.w[0] == 0x0ull)) { 3268 // x is 0 3269 res = 0x00000000; 3270 BID_RETURN (res); 3271 } else { // x is not special and is not zero 3272 3273 // q = nr. of decimal digits in x 3274 // determine first the nr. of bits in x 3275 if (C1.w[1] == 0) { 3276 if (C1.w[0] >= 0x0020000000000000ull) { // x >= 2^53 3277 // split the 64-bit value in two 32-bit halves to avoid rounding errors 3278 if (C1.w[0] >= 0x0000000100000000ull) { // x >= 2^32 3279 tmp1.d = (double) (C1.w[0] >> 32); // exact conversion 3280 x_nr_bits = 3281 33 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 3282 } else { // x < 2^32 3283 tmp1.d = (double) (C1.w[0]); // exact conversion 3284 x_nr_bits = 3285 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 3286 } 3287 } else { // if x < 2^53 3288 tmp1.d = (double) C1.w[0]; // exact conversion 3289 x_nr_bits = 3290 1 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 3291 } 3292 } else { // C1.w[1] != 0 => nr. bits = 64 + nr_bits (C1.w[1]) 3293 tmp1.d = (double) C1.w[1]; // exact conversion 3294 x_nr_bits = 3295 65 + ((((unsigned int) (tmp1.ui64 >> 52)) & 0x7ff) - 0x3ff); 3296 } 3297 q = nr_digits[x_nr_bits - 1].digits; 3298 if (q == 0) { 3299 q = nr_digits[x_nr_bits - 1].digits1; 3300 if (C1.w[1] > nr_digits[x_nr_bits - 1].threshold_hi 3301 || (C1.w[1] == nr_digits[x_nr_bits - 1].threshold_hi 3302 && C1.w[0] >= nr_digits[x_nr_bits - 1].threshold_lo)) 3303 q++; 3304 } 3305 exp = (x_exp >> 49) - 6176; 3306 if ((q + exp) > 10) { // x >= 10^10 ~= 2^33.2... (cannot fit in 32 bits) 3307 // set invalid flag 3308 *pfpsf |= INVALID_EXCEPTION; 3309 // return Integer Indefinite 3310 res = 0x80000000; 3311 BID_RETURN (res); 3312 } else if ((q + exp) == 10) { // x = c(0)c(1)...c(9).c(10)...c(q-1) 3313 // in this case 2^29.89... ~= 10^9 <= x < 10^10 ~= 2^33.2... 3314 // so x rounded to an integer may or may not fit in a signed 32-bit int 3315 // the cases that do not fit are identified here; the ones that fit 3316 // fall through and will be handled with other cases further, 3317 // under '1 <= q + exp <= 10' 3318 if (x_sign) { // if n < 0 and q + exp = 10 3319 // if n <= -1/2 then n is too large 3320 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 1/2 3321 // <=> 0.c(0)c(1)...c(q-1) * 10^11 >= 0x05, 1<=q<=34 3322 if (q <= 11) { 3323 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 3324 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 3325 if (tmp64 >= 0x05ull) { 3326 // set invalid flag 3327 *pfpsf |= INVALID_EXCEPTION; 3328 // return Integer Indefinite 3329 res = 0x80000000; 3330 BID_RETURN (res); 3331 } 3332 // else cases that can be rounded to a 32-bit int fall through 3333 // to '1 <= q + exp <= 10' 3334 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 3335 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x05 <=> 3336 // C >= 0x05 * 10^(q-11) where 1 <= q - 11 <= 23 3337 // (scale 1/2 up) 3338 tmp64 = 0x05ull; 3339 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 3340 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 3341 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 3342 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 3343 } 3344 if (C1.w[1] > C.w[1] 3345 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 3346 // set invalid flag 3347 *pfpsf |= INVALID_EXCEPTION; 3348 // return Integer Indefinite 3349 res = 0x80000000; 3350 BID_RETURN (res); 3351 } 3352 // else cases that can be rounded to a 32-bit int fall through 3353 // to '1 <= q + exp <= 10' 3354 } 3355 } else { // if n > 0 and q + exp = 10 3356 // if n >= 2^32 - 1/2 then n is too large 3357 // too large if c(0)c(1)...c(9).c(10)...c(q-1) >= 2^32-1/2 3358 // too large if 0.c(0)c(1)...c(q-1) * 10^11 >= 0x9fffffffb, 1<=q<=34 3359 if (q <= 11) { 3360 tmp64 = C1.w[0] * ten2k64[11 - q]; // C scaled up to 11-digit int 3361 // c(0)c(1)...c(9)c(10) or c(0)c(1)...c(q-1)0...0 (11 digits) 3362 if (tmp64 >= 0x9fffffffbull) { 3363 // set invalid flag 3364 *pfpsf |= INVALID_EXCEPTION; 3365 // return Integer Indefinite 3366 res = 0x80000000; 3367 BID_RETURN (res); 3368 } 3369 // else cases that can be rounded to a 32-bit int fall through 3370 // to '1 <= q + exp <= 10' 3371 } else { // if (q > 11), i.e. 12 <= q <= 34 and so -24 <= exp <= -2 3372 // 0.c(0)c(1)...c(q-1) * 10^11 >= 0x9fffffffb <=> 3373 // C >= 0x9fffffffb * 10^(q-11) where 1 <= q - 11 <= 23 3374 // (scale 2^32-1/2 up) 3375 tmp64 = 0x9fffffffbull; 3376 if (q - 11 <= 19) { // 1 <= q - 11 <= 19; 10^(q-11) requires 64 bits 3377 __mul_64x64_to_128MACH (C, tmp64, ten2k64[q - 11]); 3378 } else { // 20 <= q - 11 <= 23, and 10^(q-11) requires 128 bits 3379 __mul_128x64_to_128 (C, tmp64, ten2k128[q - 31]); 3380 } 3381 if (C1.w[1] > C.w[1] 3382 || (C1.w[1] == C.w[1] && C1.w[0] >= C.w[0])) { 3383 // set invalid flag 3384 *pfpsf |= INVALID_EXCEPTION; 3385 // return Integer Indefinite 3386 res = 0x80000000; 3387 BID_RETURN (res); 3388 } 3389 // else cases that can be rounded to a 32-bit int fall through 3390 // to '1 <= q + exp <= 10' 3391 } 3392 } 3393 } 3394 // n is not too large to be converted to int32: -1/2 < n < 2^32 - 1/2 3395 // Note: some of the cases tested for above fall through to this point 3396 if ((q + exp) < 0) { // n = +/-0.0...c(0)c(1)...c(q-1) 3397 // set inexact flag 3398 *pfpsf |= INEXACT_EXCEPTION; 3399 // return 0 3400 res = 0x00000000; 3401 BID_RETURN (res); 3402 } else if ((q + exp) == 0) { // n = +/-0.c(0)c(1)...c(q-1) 3403 // if 0.c(0)c(1)...c(q-1) < 0.5 <=> c(0)c(1)...c(q-1) < 5 * 10^(q-1) 3404 // res = 0 3405 // else if x > 0 3406 // res = +1 3407 // else // if x < 0 3408 // invalid exc 3409 ind = q - 1; 3410 if (ind <= 18) { // 0 <= ind <= 18 3411 if ((C1.w[1] == 0) && (C1.w[0] < midpoint64[ind])) { 3412 res = 0x00000000; // return 0 3413 } else if (!x_sign) { // n > 0 3414 res = 0x00000001; // return +1 3415 } else { 3416 res = 0x80000000; 3417 *pfpsf |= INVALID_EXCEPTION; 3418 BID_RETURN (res); 3419 } 3420 } else { // 19 <= ind <= 33 3421 if ((C1.w[1] < midpoint128[ind - 19].w[1]) 3422 || ((C1.w[1] == midpoint128[ind - 19].w[1]) 3423 && (C1.w[0] < midpoint128[ind - 19].w[0]))) { 3424 res = 0x00000000; // return 0 3425 } else if (!x_sign) { // n > 0 3426 res = 0x00000001; // return +1 3427 } else { 3428 res = 0x80000000; 3429 *pfpsf |= INVALID_EXCEPTION; 3430 BID_RETURN (res); 3431 } 3432 } 3433 // set inexact flag 3434 *pfpsf |= INEXACT_EXCEPTION; 3435 } else { // if (1 <= q + exp <= 10, 1 <= q <= 34, -33 <= exp <= 9) 3436 if (x_sign) { // x <= -1 3437 // set invalid flag 3438 *pfpsf |= INVALID_EXCEPTION; 3439 // return Integer Indefinite 3440 res = 0x80000000; 3441 BID_RETURN (res); 3442 } 3443 // 1 <= x < 2^31-1/2 so x can be rounded 3444 // to nearest-away to a 32-bit signed integer 3445 if (exp < 0) { // 2 <= q <= 34, -33 <= exp <= -1, 1 <= q + exp <= 10 3446 ind = -exp; // 1 <= ind <= 33; ind is a synonym for 'x' 3447 // chop off ind digits from the lower part of C1 3448 // C1 = C1 + 1/2 * 10^ind where the result C1 fits in 127 bits 3449 tmp64 = C1.w[0]; 3450 if (ind <= 19) { 3451 C1.w[0] = C1.w[0] + midpoint64[ind - 1]; 3452 } else { 3453 C1.w[0] = C1.w[0] + midpoint128[ind - 20].w[0]; 3454 C1.w[1] = C1.w[1] + midpoint128[ind - 20].w[1]; 3455 } 3456 if (C1.w[0] < tmp64) 3457 C1.w[1]++; 3458 // calculate C* and f* 3459 // C* is actually floor(C*) in this case 3460 // C* and f* need shifting and masking, as shown by 3461 // shiftright128[] and maskhigh128[] 3462 // 1 <= x <= 33 3463 // kx = 10^(-x) = ten2mk128[ind - 1] 3464 // C* = (C1 + 1/2 * 10^x) * 10^(-x) 3465 // the approximation of 10^(-x) was rounded up to 118 bits 3466 __mul_128x128_to_256 (P256, C1, ten2mk128[ind - 1]); 3467 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 3468 Cstar.w[1] = P256.w[3]; 3469 Cstar.w[0] = P256.w[2]; 3470 fstar.w[3] = 0; 3471 fstar.w[2] = P256.w[2] & maskhigh128[ind - 1]; 3472 fstar.w[1] = P256.w[1]; 3473 fstar.w[0] = P256.w[0]; 3474 } else { // 22 <= ind - 1 <= 33 3475 Cstar.w[1] = 0; 3476 Cstar.w[0] = P256.w[3]; 3477 fstar.w[3] = P256.w[3] & maskhigh128[ind - 1]; 3478 fstar.w[2] = P256.w[2]; 3479 fstar.w[1] = P256.w[1]; 3480 fstar.w[0] = P256.w[0]; 3481 } 3482 // the top Ex bits of 10^(-x) are T* = ten2mk128trunc[ind], e.g. 3483 // if x=1, T*=ten2mk128trunc[0]=0x19999999999999999999999999999999 3484 // if (0 < f* < 10^(-x)) then the result is a midpoint 3485 // if floor(C*) is even then C* = floor(C*) - logical right 3486 // shift; C* has p decimal digits, correct by Prop. 1) 3487 // else if floor(C*) is odd C* = floor(C*)-1 (logical right 3488 // shift; C* has p decimal digits, correct by Pr. 1) 3489 // else 3490 // C* = floor(C*) (logical right shift; C has p decimal digits, 3491 // correct by Property 1) 3492 // n = C* * 10^(e+x) 3493 3494 // shift right C* by Ex-128 = shiftright128[ind] 3495 shift = shiftright128[ind - 1]; // 0 <= shift <= 102 3496 if (ind - 1 <= 21) { // 0 <= ind - 1 <= 21 3497 Cstar.w[0] = 3498 (Cstar.w[0] >> shift) | (Cstar.w[1] << (64 - shift)); 3499 // redundant, it will be 0! Cstar.w[1] = (Cstar.w[1] >> shift); 3500 } else { // 22 <= ind - 1 <= 33 3501 Cstar.w[0] = (Cstar.w[0] >> (shift - 64)); // 2 <= shift - 64 <= 38 3502 } 3503 // if the result was a midpoint, it was already rounded away from zero 3504 // determine inexactness of the rounding of C* 3505 // if (0 < f* - 1/2 < 10^(-x)) then 3506 // the result is exact 3507 // else // if (f* - 1/2 > T*) then 3508 // the result is inexact 3509 if (ind - 1 <= 2) { 3510 if (fstar.w[1] > 0x8000000000000000ull || 3511 (fstar.w[1] == 0x8000000000000000ull 3512 && fstar.w[0] > 0x0ull)) { 3513 // f* > 1/2 and the result may be exact 3514 tmp64 = fstar.w[1] - 0x8000000000000000ull; // f* - 1/2 3515 if (tmp64 > ten2mk128trunc[ind - 1].w[1] 3516 || (tmp64 == ten2mk128trunc[ind - 1].w[1] 3517 && fstar.w[0] >= ten2mk128trunc[ind - 1].w[0])) { 3518 // set the inexact flag 3519 // *pfpsf |= INEXACT_EXCEPTION; 3520 tmp_inexact = 1; 3521 } // else the result is exact 3522 } else { // the result is inexact; f2* <= 1/2 3523 // set the inexact flag 3524 // *pfpsf |= INEXACT_EXCEPTION; 3525 tmp_inexact = 1; 3526 } 3527 } else if (ind - 1 <= 21) { // if 3 <= ind <= 21 3528 if (fstar.w[3] > 0x0 || 3529 (fstar.w[3] == 0x0 && fstar.w[2] > onehalf128[ind - 1]) || 3530 (fstar.w[3] == 0x0 && fstar.w[2] == onehalf128[ind - 1] && 3531 (fstar.w[1] || fstar.w[0]))) { 3532 // f2* > 1/2 and the result may be exact 3533 // Calculate f2* - 1/2 3534 tmp64 = fstar.w[2] - onehalf128[ind - 1]; 3535 tmp64A = fstar.w[3]; 3536 if (tmp64 > fstar.w[2]) 3537 tmp64A--; 3538 if (tmp64A || tmp64 3539 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 3540 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 3541 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 3542 // set the inexact flag 3543 // *pfpsf |= INEXACT_EXCEPTION; 3544 tmp_inexact = 1; 3545 } // else the result is exact 3546 } else { // the result is inexact; f2* <= 1/2 3547 // set the inexact flag 3548 // *pfpsf |= INEXACT_EXCEPTION; 3549 tmp_inexact = 1; 3550 } 3551 } else { // if 22 <= ind <= 33 3552 if (fstar.w[3] > onehalf128[ind - 1] || 3553 (fstar.w[3] == onehalf128[ind - 1] && 3554 (fstar.w[2] || fstar.w[1] || fstar.w[0]))) { 3555 // f2* > 1/2 and the result may be exact 3556 // Calculate f2* - 1/2 3557 tmp64 = fstar.w[3] - onehalf128[ind - 1]; 3558 if (tmp64 || fstar.w[2] 3559 || fstar.w[1] > ten2mk128trunc[ind - 1].w[1] 3560 || (fstar.w[1] == ten2mk128trunc[ind - 1].w[1] 3561 && fstar.w[0] > ten2mk128trunc[ind - 1].w[0])) { 3562 // set the inexact flag 3563 // *pfpsf |= INEXACT_EXCEPTION; 3564 tmp_inexact = 1; 3565 } // else the result is exact 3566 } else { // the result is inexact; f2* <= 1/2 3567 // set the inexact flag 3568 // *pfpsf |= INEXACT_EXCEPTION; 3569 tmp_inexact = 1; 3570 } 3571 } 3572 // no need to check for midpoints - already rounded away from zero! 3573 res = Cstar.w[0]; // the result is positive 3574 if (tmp_inexact) 3575 *pfpsf |= INEXACT_EXCEPTION; 3576 } else if (exp == 0) { 3577 // 1 <= q <= 10 3578 // res = +C (exact) 3579 res = C1.w[0]; 3580 } else { // if (exp > 0) => 1 <= exp <= 9, 1 <= q < 9, 2 <= q + exp <= 10 3581 // res = +C * 10^exp (exact) 3582 res = C1.w[0] * ten2k64[exp]; 3583 } 3584 } 3585 } 3586 3587 BID_RETURN (res); 3588 } 3589