Lines Matching defs:man
5337 uint64_t man = u & 0x3FF;
5342 } else if (man != 0) { // Subnormal but non-zero.
5343 uint32_t clz = wuffs_base__count_leading_zeroes_u64(man);
5345 man = 0x3FF & (man << (clz - 53));
5349 v |= (exp << 52) | (man << 42);
13106 uint64_t man = u & 0x000FFFFFFFFFFFFF;
13109 if (man == 0) { // Infinity.
13119 ret.value = neg | 0x7DFF | ((uint16_t)(man >> 42));
13138 man |= 0x0010000000000000;
13140 uint64_t shifted_man = man >> shift;
13143 ret.lossy = (shifted_man << shift) != man;
13156 ret.value = neg | ((uint16_t)exp) | ((uint16_t)(man >> 42));
13157 ret.lossy = (man << 22) != 0;
13170 uint64_t man = u & 0x000FFFFFFFFFFFFF;
13173 if (man == 0) { // Infinity.
13183 ret.value = neg | 0x7FBFFFFF | ((uint32_t)(man >> 29));
13202 man |= 0x0010000000000000;
13204 uint64_t shifted_man = man >> shift;
13207 ret.lossy = (shifted_man << shift) != man;
13220 ret.value = neg | ((uint32_t)exp) | ((uint32_t)(man >> 29));
13221 ret.lossy = (man << 35) != 0;
14043 // - when parsing "12345.678e+02", man is 12345678 and exp10 is -1.
14044 // - when parsing "-12", man is 12 and exp10 is 0. Processing the leading
14059 // - man is non-zero.
14063 // The exp10 range (and the fact that man is in the range [1 ..= UINT64_MAX],
14064 // approximately [1 ..= 1.85e+19]) means that (man * (10 ** exp10)) is in the
14070 uint64_t man,
14078 // Normalize the man argument. The (man != 0) precondition means that a
14080 uint32_t clz = wuffs_base__count_leading_zeroes_u64(man);
14081 man <<= clz;
14107 wuffs_base__multiply_u64__output x = wuffs_base__multiply_u64(man, po10[1]);
14113 // for the product (man * e), where e is (10 ** exp10). The upper bound would
14114 // add a further (man * 1) to the 128-bit product, which overflows the lower
14115 // 64-bit limb if ((x_lo + man) < man).
14125 // - man = 0x8AC7230489E7FFFF
14126 if (((x_hi & 0x1FF) == 0x1FF) && ((x_lo + man) < man)) {
14127 // Refine our calculation of (man * e). Before, our approximation of e used
14129 // mantissa. We've already calculated x = (man * bits_0_to_63_incl_of_e).
14130 // Now calculate y = (man * bits_64_to_127_incl_of_e).
14131 wuffs_base__multiply_u64__output y = wuffs_base__multiply_u64(man, po10[0]);
14136 // calculate the 192-bit product of the 64-bit man by the 128-bit e.
14166 // - man = 0xD3C21BCECCEDA100
14168 (y_lo + man < man)) {
14361 // Try the fast Eisel-Lemire algorithm again. Calculating the (man, exp10)
14367 uint64_t man = 0;
14370 man = (10 * man) + h->digits[i];
14373 if ((man != 0) && (-307 <= exp10) && (exp10 <= 288)) {
14376 man, exp10);
14522 // This (u64 man, i32 exp10) data structure is superficially similar to the
14526 // If s's number fits in a (man, exp10), parse that pair with the
14535 // Calculating that (man, exp10) pair needs to stay within s's bounds.
14566 // Update the man variable during the walk. It's OK if man overflows now.
14568 uint64_t man;
14570 man = 0;
14576 man = ((uint8_t)(*p - '0'));
14579 man = (10 * man) + ((uint8_t)(*p - '0'));
14586 // updating the man and exp10 variables.
14597 man = (10 * man) + ((uint8_t)(*p - '0'));
14600 man = (10 * man) + ((uint8_t)(*p - '0'));
14656 // Check that the uint64_t typed man variable has not overflowed, based on
14690 // If both man and (10 ** exp10) are exactly representable by a double, we
14692 if ((-22 <= exp10) && (exp10 <= 22) && ((man >> 53) == 0)) {
14693 double d = (double)man;
14706 // preconditions include that man is non-zero. Parsing "0" should be caught
14707 // by the "If both man and (10 ** exp10)" above, but "0e99" might not.
14708 if (man == 0) {
14712 // Our man and exp10 are in range. Run the Eisel-Lemire algorithm.
14715 man, exp10);
14940 uint64_t man = bits & 0x000FFFFFFFFFFFFFul;
14945 if (man != 0) {
14953 man |= 0x0010000000000000ul;
14961 // Convert from the (neg, exp2, man) tuple to an HPD.
14963 wuffs_base__private_implementation__high_prec_dec__assign(&h, man, neg);
14975 &h, exp2, man);
14988 &h, exp2, man);
15004 &h, exp2, man);