internal/math/biguintcore.d

56 // dipatchers to the right low-level primitives. Added to allow BigInt CTFE for
137 void multibyteMultiplyAccumulate()(uint[] dest, const(uint)[] left, const(uint)[] right)
140         std.internal.math.biguintnoasm.multibyteMultiplyAccumulate(dest, left, right);
142         std.internal.math.biguintx86.multibyteMultiplyAccumulate(dest, left, right);
144         std.internal.math.biguintnoasm.multibyteMultiplyAccumulate(dest, left, right);
716         assert(y > 0, "Can not right shift BigUint by 0");
1019      * Method: Powers of 2 are removed from x, then left-to-right binary
1144             // It's not worth right shifting by evenbits unless we also shrink the length after each
2193         const(BigDigit)[] right) pure nothrow @safe
2196     assert(result.length == left.length + right.length,
2197         "Result must be able to store left + right");
2198     assert(right.length>1, "right must not be empty");
2202     result[left.length] = multibyteMul(result[0 .. left.length], left, right[0], 0);
2203     multibyteMultiplyAccumulate(result[1..$], left, right[1..$]);
2222 uint addSimple(BigDigit[] result, const BigDigit [] left, const BigDigit [] right)
2228     assert(left.length >= right.length,
2229         "left must be longer or of equal length to right");
2230     assert(right.length > 0, "right must not be empty");
2234     uint carry = multibyteAdd(result[0 .. right.length],
2235             left[0 .. right.length], right, 0);
2236     if (right.length < left.length)
2238         result[right.length .. left.length] = left[right.length .. $];
2239         carry = multibyteIncrementAssign!('+')(result[right.length..$], carry);
2244 //  result = left - right
2247         const(BigDigit) [] right) pure nothrow
2252     assert(left.length >= right.length,
2253         "left must be longer or of equal length to right");
2254     assert(right.length > 0, "right must not be empty");
2258     BigDigit carry = multibyteSub(result[0 .. right.length],
2259             left[0 .. right.length], right, 0);
2260     if (right.length < left.length)
2262         result[right.length .. left.length] = left[right.length .. $];
2263         carry = multibyteIncrementAssign!('-')(result[right.length..$], carry);
2269 /* result = result - right
2270  * Returns carry = 1 if result was less than right.
2272 BigDigit subAssignSimple(BigDigit [] result, const(BigDigit) [] right)
2275     assert(result.length >= right.length,
2276        "result must be longer or of equal length to right");
2277     uint c = multibyteSub(result[0 .. right.length], result[0 .. right.length], right, 0);
2278     if (c && result.length > right.length)
2279         c = multibyteIncrementAssign!('-')(result[right.length .. $], c);
2283 /* result = result + right
2285 BigDigit addAssignSimple(BigDigit [] result, const(BigDigit) [] right)
2288     assert(result.length >= right.length,
2289        "result must be longer or of equal length to right");
2290     uint c = multibyteAdd(result[0 .. right.length], result[0 .. right.length], right, 0);
2291     if (c && result.length > right.length)
2292        c = multibyteIncrementAssign!('+')(result[right.length .. $], c);
2296 /* performs result += wantSub? - right : right;
2298 BigDigit addOrSubAssignSimple(BigDigit [] result, const(BigDigit) [] right,
2302         return subAssignSimple(result, right);
2304         return addAssignSimple(result, right);
2668 // Returns the highest value of i for which left[i]!=right[i],
2669 // or 0 if left[] == right[]
2670 size_t highestDifferentDigit(const BigDigit [] left, const BigDigit [] right)
2673     assert(left.length == right.length,
2674         "left have a length equal to that of right");
2677         if (left[i] != right[i])