mulWrap

rma = a * b with 2s-complement wrapping semantics.

rma may alias with a or b. a and b may alias with each other.

Asserts the result fits in rma. An upper bound on the number of limbs needed by rma is given by a.limbs.len + b.limbs.len.

limbs_buffer is used for temporary storage. The amount required is given by calcMulWrapLimbsBufferLen.

Function parameters

Parameters

rma:*Mutable
a:Const
b:Const
signedness:Signedness
bit_count:usize
limbs_buffer:[]Limb
allocator:?Allocator

Used to indicate either limit of a 2s-complement integer.

Types

TwosCompIntLimit: Used to indicate either limit of a 2s-complement integer.
Round
Exactness
Mutable: A arbitrary-precision big integer, with a fixed set of mutable limbs.
Const: A arbitrary-precision big integer, with a fixed set of immutable limbs.
Managed: An arbitrary-precision big integer along with an allocator which manages the memory.

Returns the number of limbs needed to store `scalar`, which must be a

Functions

calcLimbLen: Returns the number of limbs needed to store `scalar`, which must be a
calcToStringLimbsBufferLen
calcDivLimbsBufferLen
calcMulLimbsBufferLen
calcMulWrapLimbsBufferLen
calcSetStringLimbsBufferLen
calcSetStringLimbCount: Assumes `string_len` doesn't account for minus signs if the number is negative.
calcPowLimbsBufferLen
calcSqrtLimbsBufferLen
calcNonZeroTwosCompLimbCount: Compute the number of limbs required to store a 2s-complement number of `bit_count` bits.
calcTwosCompLimbCount: Compute the number of limbs required to store a 2s-complement number of `bit_count` bits.
addMulLimbWithCarry: a + b * c + *carry, sets carry to the overflow bits
llcmp: Returns -1, 0, 1 if |a| < |b|, |a| == |b| or |a| > |b| respectively for limbs.

Source

Implementation

pub fn mulWrap(
    rma: *Mutable,
    a: Const,
    b: Const,
    signedness: Signedness,
    bit_count: usize,
    limbs_buffer: []Limb,
    allocator: ?Allocator,
) void {
    var buf_index: usize = 0;
    const req_limbs = calcTwosCompLimbCount(bit_count);

    const a_copy = if (rma.limbs.ptr == a.limbs.ptr) blk: {
        const start = buf_index;
        const a_len = @min(req_limbs, a.limbs.len);
        @memcpy(limbs_buffer[buf_index..][0..a_len], a.limbs[0..a_len]);
        buf_index += a_len;
        break :blk a.toMutable(limbs_buffer[start..buf_index]).toConst();
    } else a;

    const b_copy = if (rma.limbs.ptr == b.limbs.ptr) blk: {
        const start = buf_index;
        const b_len = @min(req_limbs, b.limbs.len);
        @memcpy(limbs_buffer[buf_index..][0..b_len], b.limbs[0..b_len]);
        buf_index += b_len;
        break :blk a.toMutable(limbs_buffer[start..buf_index]).toConst();
    } else b;

    return rma.mulWrapNoAlias(a_copy, b_copy, signedness, bit_count, allocator);
}