Lines Matching refs:that
49 /// A utility function that converts a character to a digit.
86 void APInt::initSlowCase(const APInt& that) {
88 memcpy(U.pVal, that.U.pVal, getNumWords() * APINT_WORD_SIZE);
447 // Extracting bits that start on a source word boundary can be done
523 // the first few digits. But, I'm not sure how accurate that could be.
525 // Compute a sufficient number of bits that is always large enough but might
528 // bits in that case.
561 // We can check that all parts of an integer are equal by making use of a
828 // we are using. Note that the sign bit is gone since we constructed the
1060 // Extend the rotate APInt, so that the urem doesn't divide by 0.
1177 /// signifying that no multiplicative inverse exists!
1183 // (especially the properties numbered 3, 4 and 9) it can be proved that
1221 /// by a constant as a sequence of multiplies, adds and shifts. Requires that
1264 /// Requires that the divisor not be 0. Taken from "Hacker's Delight", Henry
1342 // u and v by d. Note that we have taken Knuth's advice here to use a power
1343 // of 2 value for d such that d * v[n-1] >= b/2 (b is the base). A power of
1346 // and v so that its high bits are shifted to the top of v's range without
1347 // overflow. Note that this can require an extra word in u so that u must
1424 // D6. [Add back]. The probability that this step is necessary is very
1425 // small, on the order of only 2/b. Make sure that test data accounts for
1430 // since it cancels with the borrow that occurred in D4.
1546 // and faster because we are certain that we can divide a 64-bit quantity
1830 // NOTE: This assumes that reallocate won't affect any bits if it doesn't
1897 // NOTE: This assumes that reallocate won't affect any bits if it doesn't
2279 /// Returns the APInt as a std::string. Note that this is an inefficient method.
2414 srcLSB, to DST, of dstCOUNT parts, such that the bit srcLSB becomes
2430 in DST. If this is less that srcBits, append the rest, else
2686 /* Loop, subtracting SRHS if REMAINDER is greater and adding that to
2884 // The operation done below (on quadratic coefficients) that can produce
2912 // that "wrap around", such a set will always have a solution, i.e. an x
2913 // that satisfies at least one of the equations, or such that |q(x)|
2916 // We need to find a value k, such that Ax^2 + Bx + C = kR will have a
2917 // positive solution n (in the above sense), and also such that the n
2920 // { n(k) | k is such that a solution n(k) exists }).
2922 // Consider the parabola (over real numbers) that corresponds to the
2947 // order to have a non-negative solution we need to pick k that makes
2949 // that we are looking for, it needs to be closest to 0 of all k.
2957 // to exist, the discriminant must be non-negative. This means that
2964 // If there exists k meeting the condition above, and such that
2966 // q(x) = kR. Out of all such values of k, pick the one that makes
2967 // C-kR closest to 0, (i.e. pick maximum k such that C-kR > 0).
2968 // In other words, find maximum k such that LowkR <= kR < C.
2976 // If C-kR < 0 for all potential k's, it means that one solution
2980 // to 0, or in other words, out of all parabolas that have solutions,
2981 // pick the one that is the farthest "up").
2999 // value. If that's the case, decrement SQ to get a value that is lower.
3009 // To make sure that the calculated root is not greater than the exact
3017 // The updated coefficients should be such that the (exact) solution is
3029 // This implies that the solution should be between that corresponding to
3030 // SQ (i.e. X) and that corresponding to SQ+1.