DoxigAlpha

bitOr

r = a | b under 2s complement semantics. r may alias with a or b.

a and b are zero-extended to the longer of a or b.

Asserts that r has enough limbs to store the result. Upper bound is @max(a.limbs.len, b.limbs.len).

Function parameters

Parameters

#
r:*Mutable

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 bitOr(r: *Mutable, a: Const, b: Const) void {
    // Trivial cases, llsignedor does not support zero.
    if (a.eqlZero()) {
        r.copy(b);
        return;
    } else if (b.eqlZero()) {
        r.copy(a);
        return;
    }

    if (a.limbs.len >= b.limbs.len) {
        r.positive = llsignedor(r.limbs, a.limbs, a.positive, b.limbs, b.positive);
        r.normalize(if (b.positive) a.limbs.len else b.limbs.len);
    } else {
        r.positive = llsignedor(r.limbs, b.limbs, b.positive, a.limbs, a.positive);
        r.normalize(if (a.positive) b.limbs.len else a.limbs.len);
    }
}