DoxigAlpha
std › math › big › int.Mutable › mul

mul

rma = a * b

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 calcMulLimbsBufferLen.

Function parameters

Parameters

#
rma:*Mutable
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.
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
calcSetStringLimbCount
Assumes `string_len` doesn't account for minus signs if the number is negative.
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 mul(rma: *Mutable, a: Const, b: Const, limbs_buffer: []Limb, allocator: ?Allocator) void {
    var buf_index: usize = 0;

    const a_copy = if (rma.limbs.ptr == a.limbs.ptr) blk: {
        const start = buf_index;
        @memcpy(limbs_buffer[buf_index..][0..a.limbs.len], a.limbs);
        buf_index += a.limbs.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;
        @memcpy(limbs_buffer[buf_index..][0..b.limbs.len], b.limbs);
        buf_index += b.limbs.len;
        break :blk b.toMutable(limbs_buffer[start..buf_index]).toConst();
    } else b;

    return rma.mulNoAlias(a_copy, b_copy, allocator);
}