IntInit

Documentation

API Reference

IntInit

Description

Create an empty integer with value 0.

This public macro supports both forms:

IntInit() - uses DefaultAllocator().
IntInit(alloc) - binds the supplied allocator.

Parameters

Name	Direction	Description
`alloc`	in	Optional allocator override.

Usage example (from documentation)

  Int value = IntInit();

Success

Returns a fresh empty Int representing zero, with the chosen allocator bound to its internal BitVec storage. No heap allocation happens until the integer is mutated.

Failure

Function cannot fail.

Usage example (Cross-references)

Usage examples (Cross-references)

In Io.c:3192:

    
        Str  temp   = StrInitFromCstr(start, i - start);
        Int  parsed = IntInit();
        bool ok     = IntTryFromStrRadix(&parsed, temp.data, radix);

In Float.c:94:

        }
    
        *out = IntInit(alloc);
        if (value == 0) {
            return true;

In Float.c:105:

        if (!BitVecTryFromIntegerAlloc(&out->bits, value, bits, alloc)) {
            IntDeinit(out);
            *out = IntInit(alloc);
            return false;
        }

In Float.c:152:

        {
            u64 places = (u64)(value->exponent - target_exponent);
            Int factor = IntInit(value->significand.bits.allocator);
            Int scaled = IntInit(value->significand.bits.allocator);

In Float.c:153:

            u64 places = (u64)(value->exponent - target_exponent);
            Int factor = IntInit(value->significand.bits.allocator);
            Int scaled = IntInit(value->significand.bits.allocator);
    
            if (!float_pow10(&factor, places, value->significand.bits.allocator) ||

In Float.c:214:

    
        while (int_mod_u64(&value->significand, 10) == 0) {
            Int quotient = IntInit(value->significand.bits.allocator);
    
            (void)int_div_u64_rem(&quotient, &value->significand, 10);

In Float.c:363:

    
    bool FloatToInt(Int *result, Float *value) {
        Int temp = IntInit(result->bits.allocator);
    
        ValidateInt(result);

In Float.c:380:

    
        if (value->exponent >= 0) {
            Int factor = IntInit(value->significand.bits.allocator);
    
            if (!IntTryClone(&temp, &value->significand) ||

In Float.c:398:

        {
            u64  places = (u64)(-value->exponent);
            Int  factor = IntInit(value->significand.bits.allocator);
            bool ok     = false;

In Float.c:1073:

    bool float_div(Float *result, Float *a, Float *b, u64 precision) {
        Float temp   = FloatInit(result->significand.bits.allocator);
        Int   scale  = IntInit(result->significand.bits.allocator);
        Int   scaled = IntInit(result->significand.bits.allocator);

In Float.c:1074:

        Float temp   = FloatInit(result->significand.bits.allocator);
        Int   scale  = IntInit(result->significand.bits.allocator);
        Int   scaled = IntInit(result->significand.bits.allocator);
    
        ValidateFloat(result);

In Int.c:44:

        if (capacity != 0 && out->bits.capacity < capacity) {
            IntDeinit(out);
            *out = IntInit(alloc);
            return false;
        }

In Int.c:59:

        }
    
        *out = IntInit(alloc);
        if (bits == 0) {
            return true;

In Int.c:66:

        if (!BitVecTryFromIntegerAlloc(INT_BITS(out), value, bits, alloc)) {
            IntDeinit(out);
            *out = IntInit(alloc);
            return false;
        }

In Int.c:125:

    
    static SignedInt sint_init(void) {
        SignedInt value = {.negative = false, .magnitude = IntInit()};
        return value;
    }

In Int.c:237:

        Int lhs;
        Int rhs;
        Int result = IntInit(value->bits.allocator);
    
        if (!int_try_clone_value(&lhs, value)) {

In Int.c:262:

        Int lhs;
        Int rhs;
        Int result = IntInit(value->bits.allocator);
    
        if (!int_try_clone_value(&lhs, value)) {

In Int.c:328:

    
        ValidateInt(out);
        result = IntInit(out->bits.allocator);
    
        if (!int_validate_radix(radix)) {

In Int.c:451:

    
        ValidateInt(value);
        *out = IntInit(value->bits.allocator);
        if (!BitVecTryClone(INT_BITS(out), INT_BITS(value))) {
            return false;

In Int.c:468:

    
        ValidateInt(value);
        clone = IntInit(value->bits.allocator);
        (void)int_try_clone_value(&clone, value);
        return clone;

In Int.c:474:

    
    Int int_from_u64(u64 value) {
        Int result = IntInit();
    
        (void)int_try_from_u64_with_allocator(&result, value, DefaultAllocator());

In Int.c:521:

        }
    
        Int result = IntInit();
    
        if (len == 0) {

In Int.c:576:

        }
    
        Int result = IntInit();
    
        for (u64 i = 0; i < len; i++) {

In Int.c:581:

            if (!IntShiftLeft(&result, 8) || !int_add_u64_in_place(&result, bytes[i])) {
                IntDeinit(&result);
                return IntInit();
            }
        }

In Int.c:641:

    
    Int IntFromStr(const char *decimal) {
        Int out = IntInit();
    
        (void)IntTryFromStr(&out, decimal);

In Int.c:683:

    
    Int IntFromStrRadix(const char *digits, u8 radix) {
        Int out = IntInit();
    
        (void)IntTryFromStrRadix(&out, digits, radix);

In Int.c:717:

    
        while (!IntIsZero(&current)) {
            Int quotient = IntInit();
            u64 digit    = 0;

In Int.c:778:

    
    Int IntFromBinary(const char *binary) {
        Int out = IntInit();
    
        (void)IntTryFromBinary(&out, binary);

In Int.c:806:

    
    Int IntFromOctStr(const char *octal) {
        Int out = IntInit();
    
        (void)IntTryFromOctStr(&out, octal);

In Int.c:826:

    
    Int IntFromHexStr(const char *hex) {
        Int out = IntInit();
    
        (void)IntTryFromHexStr(&out, hex);

In Int.c:1100:

    
        u64 b_bits = IntBitLength(b);
        Int acc    = IntInit(result->bits.allocator);
    
        if (IntIsZero(a) || IntIsZero(b)) {

In Int.c:1114:

    
            Int partial;
            Int next = IntInit(result->bits.allocator);
    
            if (!int_try_clone_value(&partial, a)) {

In Int.c:1199:

        while (exponent > 0) {
            if (exponent & 1u) {
                Int next = IntInit(result->bits.allocator);
    
                if (!int_mul(&next, &acc, &current)) {

In Int.c:1213:

            exponent >>= 1u;
            if (exponent > 0) {
                Int next = IntInit(result->bits.allocator);
    
                if (!IntSquare(&next, &current)) {

In Int.c:1253:

        }
    
        Int  normalized_dividend = IntInit(quotient->bits.allocator);
        Int  normalized_divisor  = IntInit(quotient->bits.allocator);
        Int  q                   = IntInit(quotient->bits.allocator);

In Int.c:1254:

    
        Int  normalized_dividend = IntInit(quotient->bits.allocator);
        Int  normalized_divisor  = IntInit(quotient->bits.allocator);
        Int  q                   = IntInit(quotient->bits.allocator);
        Int  r                   = IntInit(remainder->bits.allocator);

In Int.c:1255:

        Int  normalized_dividend = IntInit(quotient->bits.allocator);
        Int  normalized_divisor  = IntInit(quotient->bits.allocator);
        Int  q                   = IntInit(quotient->bits.allocator);
        Int  r                   = IntInit(remainder->bits.allocator);
        bool ok                  = false;

In Int.c:1256:

        Int  normalized_divisor  = IntInit(quotient->bits.allocator);
        Int  q                   = IntInit(quotient->bits.allocator);
        Int  r                   = IntInit(remainder->bits.allocator);
        bool ok                  = false;

In Int.c:1275:

            for (u64 shift = dividend_bits - divisor_bits + 1; shift > 0; shift--) {
                u64 bit     = shift - 1;
                Int shifted = IntInit(quotient->bits.allocator);
    
                if (!int_try_clone_value(&shifted, &normalized_divisor) || !IntShiftLeft(&shifted, bit)) {

In Int.c:1283:

    
                if (IntGE(&r, &shifted)) {
                    Int next = IntInit();
    
                    if (!int_sub(&next, &r, &shifted)) {

In Int.c:1304:

        } else {
            IntDeinit(&q);
            q = IntInit();
        }

In Int.c:1326:

    
    bool int_div(Int *result, Int *dividend, Int *divisor) {
        Int quotient  = IntInit(result->bits.allocator);
        Int remainder = IntInit(result->bits.allocator);

In Int.c:1327:

    bool int_div(Int *result, Int *dividend, Int *divisor) {
        Int quotient  = IntInit(result->bits.allocator);
        Int remainder = IntInit(result->bits.allocator);
    
        if (!int_div_mod(&quotient, &remainder, dividend, divisor)) {

In Int.c:1350:

        }
    
        Int quotient  = IntInit(result->bits.allocator);
        Int remainder = IntInit(result->bits.allocator);

In Int.c:1351:

    
        Int quotient  = IntInit(result->bits.allocator);
        Int remainder = IntInit(result->bits.allocator);
    
        if (!int_div_mod(&quotient, &remainder, dividend, divisor)) {

In Int.c:1370:

    
    bool int_div_u64(Int *result, Int *dividend, u64 divisor) {
        Int divisor_value = IntInit(dividend->bits.allocator);
    
        if (!int_try_from_u64_with_allocator(&divisor_value, divisor, dividend->bits.allocator)) {

In Int.c:1383:

    
    bool int_div_i64(Int *result, Int *dividend, i64 divisor) {
        Int divisor_value = IntInit(dividend->bits.allocator);
    
        if (!int_try_from_i64_with_allocator(&divisor_value, divisor, dividend->bits.allocator)) {

In Int.c:1396:

    
    bool int_div_exact_u64(Int *result, Int *dividend, u64 divisor) {
        Int divisor_value = IntInit(dividend->bits.allocator);
    
        if (!int_try_from_u64_with_allocator(&divisor_value, divisor, dividend->bits.allocator)) {

In Int.c:1409:

    
    bool int_div_exact_i64(Int *result, Int *dividend, i64 divisor) {
        Int divisor_value = IntInit(dividend->bits.allocator);
    
        if (!int_try_from_i64_with_allocator(&divisor_value, divisor, dividend->bits.allocator)) {

In Int.c:1422:

    
    bool int_div_mod_u64(Int *quotient, Int *remainder, Int *dividend, u64 divisor) {
        Int divisor_value = IntInit(dividend->bits.allocator);
    
        if (!int_try_from_u64_with_allocator(&divisor_value, divisor, dividend->bits.allocator)) {

In Int.c:1435:

    
    bool int_div_mod_i64(Int *quotient, Int *remainder, Int *dividend, i64 divisor) {
        Int divisor_value = IntInit(dividend->bits.allocator);
    
        if (!int_try_from_i64_with_allocator(&divisor_value, divisor, dividend->bits.allocator)) {

In Int.c:1456:

        }
    
        Int divisor_value = IntInit(dividend->bits.allocator);
        Int remainder     = IntInit(quotient->bits.allocator);
        u64 rem           = 0;

In Int.c:1457:

    
        Int divisor_value = IntInit(dividend->bits.allocator);
        Int remainder     = IntInit(quotient->bits.allocator);
        u64 rem           = 0;

In Int.c:1479:

    
    bool int_mod(Int *result, Int *dividend, Int *divisor) {
        Int quotient  = IntInit(result->bits.allocator);
        Int remainder = IntInit(result->bits.allocator);

In Int.c:1480:

    bool int_mod(Int *result, Int *dividend, Int *divisor) {
        Int quotient  = IntInit(result->bits.allocator);
        Int remainder = IntInit(result->bits.allocator);
    
        if (!int_div_mod(&quotient, &remainder, dividend, divisor)) {

In Int.c:1494:

    
    bool int_mod_u64_into(Int *result, Int *dividend, u64 divisor) {
        Int quotient = IntInit(result->bits.allocator);
    
        bool ok = int_div_mod_u64(&quotient, result, dividend, divisor);

In Int.c:1502:

    
    bool int_mod_i64_into(Int *result, Int *dividend, i64 divisor) {
        Int quotient = IntInit(result->bits.allocator);
    
        bool ok = int_div_mod_i64(&quotient, result, dividend, divisor);

In Int.c:1517:

        }
    
        Int quotient = IntInit();
        u64 rem      = int_div_u64_rem(&quotient, value, modulus);

In Int.c:1529:

        ValidateInt(b);
    
        Int x = IntInit(a->bits.allocator);
        Int y = IntInit(b->bits.allocator);

In Int.c:1530:

    
        Int x = IntInit(a->bits.allocator);
        Int y = IntInit(b->bits.allocator);
    
        if (!int_try_clone_value(&x, a) || !int_try_clone_value(&y, b)) {

In Int.c:1539:

    
        while (!IntIsZero(&y)) {
            Int r = IntInit(result->bits.allocator);
    
            if (!int_mod(&r, &x, &y)) {

In Int.c:1563:

    
        if (IntIsZero(a) || IntIsZero(b)) {
            Int zero = IntInit(result->bits.allocator);
            int_replace(result, &zero);
            return true;

In Int.c:1568:

        }
    
        Int gcd      = IntInit(result->bits.allocator);
        Int quotient = IntInit(result->bits.allocator);
        Int lcm      = IntInit(result->bits.allocator);

In Int.c:1569:

    
        Int gcd      = IntInit(result->bits.allocator);
        Int quotient = IntInit(result->bits.allocator);
        Int lcm      = IntInit(result->bits.allocator);

In Int.c:1570:

        Int gcd      = IntInit(result->bits.allocator);
        Int quotient = IntInit(result->bits.allocator);
        Int lcm      = IntInit(result->bits.allocator);
    
        if (!IntGCD(&gcd, a, b) || !int_div(&quotient, a, &gcd) || !int_mul(&lcm, &quotient, b)) {

In Int.c:1599:

    
        if (IntIsZero(value)) {
            Int zero_root = IntInit(root->bits.allocator);
            Int zero_rem  = IntInit(remainder->bits.allocator);

In Int.c:1600:

        if (IntIsZero(value)) {
            Int zero_root = IntInit(root->bits.allocator);
            Int zero_rem  = IntInit(remainder->bits.allocator);
    
            int_replace(root, &zero_root);

In Int.c:1607:

        }
        if (degree == 1) {
            Int exact_root = IntInit(root->bits.allocator);
            Int zero_rem   = IntInit(remainder->bits.allocator);

In Int.c:1608:

        if (degree == 1) {
            Int exact_root = IntInit(root->bits.allocator);
            Int zero_rem   = IntInit(remainder->bits.allocator);
    
            if (!IntTryClone(&exact_root, value)) {

In Int.c:1622:

        u64 bits       = IntBitLength(value);
        u64 high_shift = bits / degree;
        Int low        = IntInit(root->bits.allocator);
        Int high       = IntInit(root->bits.allocator);
        Int best       = IntInit(root->bits.allocator);

In Int.c:1623:

        u64 high_shift = bits / degree;
        Int low        = IntInit(root->bits.allocator);
        Int high       = IntInit(root->bits.allocator);
        Int best       = IntInit(root->bits.allocator);
        Int one        = IntInit(root->bits.allocator);

In Int.c:1624:

        Int low        = IntInit(root->bits.allocator);
        Int high       = IntInit(root->bits.allocator);
        Int best       = IntInit(root->bits.allocator);
        Int one        = IntInit(root->bits.allocator);

In Int.c:1625:

        Int high       = IntInit(root->bits.allocator);
        Int best       = IntInit(root->bits.allocator);
        Int one        = IntInit(root->bits.allocator);
    
        if ((bits % degree) != 0) {

In Int.c:1652:

    
        while (IntLE(&low, &high)) {
            Int sum     = IntInit(root->bits.allocator);
            Int mid     = IntInit(root->bits.allocator);
            Int mid_pow = IntInit(root->bits.allocator);

In Int.c:1653:

        while (IntLE(&low, &high)) {
            Int sum     = IntInit(root->bits.allocator);
            Int mid     = IntInit(root->bits.allocator);
            Int mid_pow = IntInit(root->bits.allocator);
            int cmp     = 0;

In Int.c:1654:

            Int sum     = IntInit(root->bits.allocator);
            Int mid     = IntInit(root->bits.allocator);
            Int mid_pow = IntInit(root->bits.allocator);
            int cmp     = 0;

In Int.c:1681:

    
            if (cmp <= 0) {
                Int next = IntInit(root->bits.allocator);
    
                IntDeinit(&best);

In Int.c:1707:

                low = next;
            } else {
                Int next = IntInit(root->bits.allocator);
    
                if (IntEQ(&mid, &one) || IntIsZero(&mid)) {

In Int.c:1711:

                if (IntEQ(&mid, &one) || IntIsZero(&mid)) {
                    IntDeinit(&high);
                    high = IntInit(root->bits.allocator);
                } else {
                    if (!int_sub(&next, &mid, &one)) {

In Int.c:1733:

    
        {
            Int power = IntInit(root->bits.allocator);
            Int rem   = IntInit(remainder->bits.allocator);

In Int.c:1734:

        {
            Int power = IntInit(root->bits.allocator);
            Int rem   = IntInit(remainder->bits.allocator);
    
            if (!int_pow_u64(&power, &best, degree) || !int_sub(&rem, value, &power)) {

In Int.c:1759:

    
    bool IntRoot(Int *result, Int *value, u64 degree) {
        Int root      = IntInit(result->bits.allocator);
        Int remainder = IntInit(result->bits.allocator);

In Int.c:1760:

    bool IntRoot(Int *result, Int *value, u64 degree) {
        Int root      = IntInit(result->bits.allocator);
        Int remainder = IntInit(result->bits.allocator);
    
        if (!IntRootRem(&root, &remainder, value, degree)) {

In Int.c:1784:

        ValidateInt(value);
    
        Int  root      = IntInit();
        Int  remainder = IntInit();
        bool result    = false;

In Int.c:1785:

    
        Int  root      = IntInit();
        Int  remainder = IntInit();
        bool result    = false;

In Int.c:1814:

    
        for (u64 degree = 2; degree <= max_degree; degree++) {
            Int  root      = IntInit();
            Int  remainder = IntInit();
            bool exact     = false;

In Int.c:1815:

        for (u64 degree = 2; degree <= max_degree; degree++) {
            Int  root      = IntInit();
            Int  remainder = IntInit();
            bool exact     = false;

In Int.c:1850:

        }
    
        Int aa     = IntInit(a->bits.allocator);
        Int nn     = IntInit(n->bits.allocator);
        int result = 1;

In Int.c:1851:

    
        Int aa     = IntInit(a->bits.allocator);
        Int nn     = IntInit(n->bits.allocator);
        int result = 1;

In Int.c:1922:

        }
    
        Int ar  = IntInit(result->bits.allocator);
        Int br  = IntInit(result->bits.allocator);
        Int sum = IntInit(result->bits.allocator);

In Int.c:1923:

    
        Int ar  = IntInit(result->bits.allocator);
        Int br  = IntInit(result->bits.allocator);
        Int sum = IntInit(result->bits.allocator);

In Int.c:1924:

        Int ar  = IntInit(result->bits.allocator);
        Int br  = IntInit(result->bits.allocator);
        Int sum = IntInit(result->bits.allocator);
    
        if (!int_mod(&ar, a, modulus) || !int_mod(&br, b, modulus) || !int_add(&sum, &ar, &br) ||

In Int.c:1951:

        }
    
        Int ar = IntInit(result->bits.allocator);
        Int br = IntInit(result->bits.allocator);

In Int.c:1952:

    
        Int ar = IntInit(result->bits.allocator);
        Int br = IntInit(result->bits.allocator);
    
        if (!int_mod(&ar, a, modulus) || !int_mod(&br, b, modulus)) {

In Int.c:1967:

            }
        } else {
            Int diff = IntInit(result->bits.allocator);
    
            if (!int_sub(&diff, &br, &ar)) {

In Int.c:1976:

            }
            if (IntIsZero(&diff)) {
                Int zero = IntInit(result->bits.allocator);
                int_replace(result, &zero);
            } else {

In Int.c:2006:

        }
    
        Int ar   = IntInit();
        Int br   = IntInit();
        Int prod = IntInit();

In Int.c:2007:

    
        Int ar   = IntInit();
        Int br   = IntInit();
        Int prod = IntInit();

In Int.c:2008:

        Int ar   = IntInit();
        Int br   = IntInit();
        Int prod = IntInit();
    
        if (!int_mod(&ar, a, modulus) || !int_mod(&br, b, modulus) || !int_mul(&prod, &ar, &br) ||

In Int.c:2035:

        }
    
        Int  inverse = IntInit();
        Int  value   = IntInit();
        bool ok      = false;

In Int.c:2036:

    
        Int  inverse = IntInit();
        Int  value   = IntInit();
        bool ok      = false;

In Int.c:2070:

        }
    
        Int acc      = IntInit(result->bits.allocator);
        Int base_mod = IntInit();

In Int.c:2071:

    
        Int acc      = IntInit(result->bits.allocator);
        Int base_mod = IntInit();
    
        if (!int_try_from_u64_with_allocator(&acc, 1, result->bits.allocator)) {

In Int.c:2085:

        while (exponent > 0) {
            if (exponent & 1u) {
                Int next = IntInit();
    
                if (!IntModMul(&next, &acc, &base_mod, modulus)) {

In Int.c:2099:

            exponent >>= 1u;
            if (exponent > 0) {
                Int next = IntInit();
    
                if (!IntModMul(&next, &base_mod, &base_mod, modulus)) {

In Int.c:2128:

        }
    
        Int acc      = IntInit(result->bits.allocator);
        Int base_mod = IntInit();
        Int exp      = IntInit(exponent->bits.allocator);

In Int.c:2129:

    
        Int acc      = IntInit(result->bits.allocator);
        Int base_mod = IntInit();
        Int exp      = IntInit(exponent->bits.allocator);

In Int.c:2130:

        Int acc      = IntInit(result->bits.allocator);
        Int base_mod = IntInit();
        Int exp      = IntInit(exponent->bits.allocator);
    
        if (!int_try_from_u64_with_allocator(&acc, 1, result->bits.allocator) || !IntTryClone(&exp, exponent) ||

In Int.c:2142:

        while (!IntIsZero(&exp)) {
            if (int_is_odd(&exp)) {
                Int next = IntInit();
    
                if (!IntModMul(&next, &acc, &base_mod, modulus)) {

In Int.c:2162:

            }
            if (!IntIsZero(&exp)) {
                Int next = IntInit();
    
                if (!IntModMul(&next, &base_mod, &base_mod, modulus)) {

In Int.c:2200:

        }
    
        Int       reduced = IntInit();
        SignedInt t       = sint_init();
        SignedInt new_t   = sint_from_u64(1);

In Int.c:2203:

        SignedInt t       = sint_init();
        SignedInt new_t   = sint_from_u64(1);
        Int       r       = IntInit(modulus->bits.allocator);
        Int       new_r   = IntInit();
        Int       one     = int_from_u64(1);

In Int.c:2204:

        SignedInt new_t   = sint_from_u64(1);
        Int       r       = IntInit(modulus->bits.allocator);
        Int       new_r   = IntInit();
        Int       one     = int_from_u64(1);
        bool      ok      = false;

In Int.c:2228:

    
        while (!IntIsZero(&new_r)) {
            Int       q       = IntInit();
            Int       rem     = IntInit();
            SignedInt q_new_t = sint_init();

In Int.c:2229:

        while (!IntIsZero(&new_r)) {
            Int       q       = IntInit();
            Int       rem     = IntInit();
            SignedInt q_new_t = sint_init();
            SignedInt next_t  = sint_init();

In Int.c:2232:

            SignedInt q_new_t = sint_init();
            SignedInt next_t  = sint_init();
            Int       next_r  = IntInit();
    
            if (!int_div_mod(&q, &rem, &r, &new_r) || !sint_mul_unsigned(&q_new_t, &new_t, &q) ||

In Int.c:2266:

    
        if (IntEQ(&r, &one)) {
            Int positive = IntInit();
            Int mag_mod  = IntInit();

In Int.c:2267:

        if (IntEQ(&r, &one)) {
            Int positive = IntInit();
            Int mag_mod  = IntInit();
    
            if (!int_mod(&mag_mod, &t.magnitude, modulus)) {

In Int.c:2330:

        }
    
        Int  a  = IntInit();
        bool ok = false;

In Int.c:2339:

    
        if (IntIsZero(&a)) {
            Int zero = IntInit();
            int_replace(result, &zero);
            IntDeinit(&a);

In Int.c:2369:

        }
        if (int_mod_u64(modulus, 4) == 3) {
            Int exponent = IntInit(modulus->bits.allocator);
            Int root     = IntInit();

In Int.c:2370:

        if (int_mod_u64(modulus, 4) == 3) {
            Int exponent = IntInit(modulus->bits.allocator);
            Int root     = IntInit();
    
            if (!IntTryClone(&exponent, modulus) || !int_add_u64(&exponent, &exponent, 1) || !IntShiftRight(&exponent, 2) ||

In Int.c:2387:

    
        {
            Int q        = IntInit(modulus->bits.allocator);
            Int z        = IntInit(modulus->bits.allocator);
            Int c        = IntInit();

In Int.c:2388:

        {
            Int q        = IntInit(modulus->bits.allocator);
            Int z        = IntInit(modulus->bits.allocator);
            Int c        = IntInit();
            Int t        = IntInit();

In Int.c:2389:

            Int q        = IntInit(modulus->bits.allocator);
            Int z        = IntInit(modulus->bits.allocator);
            Int c        = IntInit();
            Int t        = IntInit();
            Int r        = IntInit();

In Int.c:2390:

            Int z        = IntInit(modulus->bits.allocator);
            Int c        = IntInit();
            Int t        = IntInit();
            Int r        = IntInit();
            Int exponent = IntInit();

In Int.c:2391:

            Int c        = IntInit();
            Int t        = IntInit();
            Int r        = IntInit();
            Int exponent = IntInit();
            u64 m        = 0;

In Int.c:2392:

            Int t        = IntInit();
            Int r        = IntInit();
            Int exponent = IntInit();
            u64 m        = 0;

In Int.c:2474:

    
            while (int_compare_u64(&t, 1) != 0) {
                Int t_power = IntInit(t.bits.allocator);
                u64 i       = 0;

In Int.c:2490:

    
                for (i = 1; i < m; i++) {
                    Int next = IntInit();
    
                    if (!IntSquareMod(&next, &t_power, modulus)) {

In Int.c:2518:

    
                {
                    Int b    = IntInit(c.bits.allocator);
                    Int b_sq = IntInit();
                    Int next = IntInit();

In Int.c:2519:

                {
                    Int b    = IntInit(c.bits.allocator);
                    Int b_sq = IntInit();
                    Int next = IntInit();

In Int.c:2520:

                    Int b    = IntInit(c.bits.allocator);
                    Int b_sq = IntInit();
                    Int next = IntInit();
    
                    if (!IntTryClone(&b, &c)) {

In Int.c:2538:

    
                    for (u64 j = 0; j + i + 1 < m; j++) {
                        Int square = IntInit();
    
                        if (!IntSquareMod(&square, &b, modulus)) {

In Int.c:2589:

                        return false;
                    }
                    next = IntInit();
                    if (!IntModMul(&next, &t, &b_sq, modulus)) {
                        IntDeinit(&b);

In Int.c:2662:

    
        {
            Int  d           = IntInit(value->bits.allocator);
            Int  n_minus_one = IntInit(value->bits.allocator);
            u64  s           = 0;

In Int.c:2663:

        {
            Int  d           = IntInit(value->bits.allocator);
            Int  n_minus_one = IntInit(value->bits.allocator);
            u64  s           = 0;
            bool probable    = true;

In Int.c:2688:

    
            for (u64 i = 0; i < (u64)(sizeof(bases) / sizeof(bases[0])); i++) {
                Int base = IntInit(value->bits.allocator);
                Int x    = IntInit(value->bits.allocator);

In Int.c:2689:

            for (u64 i = 0; i < (u64)(sizeof(bases) / sizeof(bases[0])); i++) {
                Int base = IntInit(value->bits.allocator);
                Int x    = IntInit(value->bits.allocator);
    
                if (!int_try_from_u64_with_allocator(&base, bases[i], value->bits.allocator)) {

In Int.c:2722:

    
                    for (u64 r = 1; r < s; r++) {
                        Int next = IntInit(value->bits.allocator);
    
                        if (!IntSquareMod(&next, &x, value)) {

In Int.c:2766:

    
        if (int_compare_u64(value, 1) <= 0) {
            Int two = IntInit(result->bits.allocator);
    
            if (!int_try_from_u64_with_allocator(&two, 2, result->bits.allocator)) {

In Int.c:2776:

        }
    
        Int candidate = IntInit(result->bits.allocator);
    
        if (!IntTryClone(&candidate, value)) {

In Int.c:2788:

        }
        if (int_compare_u64(&candidate, 2) <= 0) {
            Int two = IntInit(result->bits.allocator);
    
            if (!int_try_from_u64_with_allocator(&two, 2, result->bits.allocator)) {

In Int.Convert.c:240:

    
        Int parsed = IntFromBinary("10a1");
        Int value  = IntInit();
        bool result = !IntTryFromBinary(&value, "10a1");

In Int.Convert.c:255:

    
        Int parsed = IntFromStr("12x3");
        Int value  = IntInit();
        bool result = !IntTryFromStr(&value, "12x3");

In Int.Convert.c:270:

    
        Int parsed = IntFromHexStr("12g3");
        Int value  = IntInit();
        bool result = !IntTryFromHexStr(&value, "12g3");

In Int.Convert.c:285:

    
        Int parsed = IntFromStrRadix("102", 2);
        Int value  = IntInit();
        bool result = !IntTryFromStrRadix(&value, "102", 2);

In Int.Convert.c:300:

    
        Int parsed = IntFromStrRadix("10", 1);
        Int value  = IntInit();
        bool result = !IntTryFromStrRadix(&value, "10", 1);

In Int.Convert.c:346:

    
        Int parsed = IntFromBinary(NULL);
        Int value  = IntInit();
        bool result = !IntTryFromBinary(&value, NULL);

In Int.Convert.c:361:

    
        Int parsed = IntFromStr(NULL);
        Int value  = IntInit();
        bool result = !IntTryFromStr(&value, NULL);

In Int.Convert.c:376:

    
        Int parsed = IntFromStrRadix(NULL, 10);
        Int value  = IntInit();
        bool result = !IntTryFromStrRadix(&value, NULL, 10);

In Int.Convert.c:391:

    
        Int parsed = IntFromOctStr(NULL);
        Int value  = IntInit();
        bool result = !IntTryFromOctStr(&value, NULL);

In Int.Convert.c:406:

    
        Int parsed = IntFromHexStr(NULL);
        Int value  = IntInit();
        bool result = !IntTryFromHexStr(&value, NULL);

In Io.Read.c:906:

        bool        success = true;
    
        Int dec = IntInit();
        Int hex = IntInit();
        Int bin = IntInit();

In Io.Read.c:907:

    
        Int dec = IntInit();
        Int hex = IntInit();
        Int bin = IntInit();
        Int oct = IntInit();

In Io.Read.c:908:

        Int dec = IntInit();
        Int hex = IntInit();
        Int bin = IntInit();
        Int oct = IntInit();

In Io.Read.c:909:

        Int hex = IntInit();
        Int bin = IntInit();
        Int oct = IntInit();
    
        Str dec_text = StrInit();

In Int.Access.c:43:

        WriteFmt("Testing IntIsZero\n");
    
        Int zero     = IntInit();
        Int non_zero = IntFrom(1);

In Int.Access.c:117:

    
        Int value = IntFromBinary("1010000");
        Int zero  = IntInit();
    
        bool result = IntTrailingZeroCount(&value) == 4;

In Int.Access.c:133:

        Int power = IntFrom(1);
        Int other = IntFrom(24);
        Int zero  = IntInit();
    
        IntShiftLeft(&power, 20);

In Int.Access.c:152:

        WriteFmt("Testing IntLog2 zero handling\n");
    
        Int  value = IntInit();
        bool error = false;

In Float.Convert.c:69:

    
        Float value        = FloatFromStr("1234500e-2");
        Int   result_value = IntInit();
        Str   text         = StrInit();

In Int.Math.c:94:

        Int a      = IntFrom(255);
        Int b      = IntFrom(1);
        Int result_value = IntInit();
        Str text   = StrInit();

In Int.Math.c:115:

        Int base         = IntFrom(40);
        Int rhs          = IntFrom(2);
        Int result_value = IntInit();
        Int huge         = IntFromStr("123456789012345678901234567890");
        Str text         = StrInit();

In Int.Math.c:145:

        Int a      = IntFrom(256);
        Int b      = IntFrom(1);
        Int result_value = IntInit();
    
        bool result = IntSub(&result_value, &a, &b);

In Int.Math.c:161:

        Int base         = IntFrom(40);
        Int rhs          = IntFrom(2);
        Int result_value = IntInit();
        Int preserved    = IntFrom(99);
        Int huge         = IntFromStr("12345678901234567890");

In Int.Math.c:212:

        Int a      = IntFrom(21);
        Int b      = IntFrom(6);
        Int result_value = IntInit();
    
        IntMul(&result_value, &a, &b);

In Int.Math.c:228:

    
        Int value = IntFromStr("12345678901234567890");
        Int result_value = IntInit();
        Str text = StrInit();

In Int.Math.c:247:

        Int a      = IntFrom(0);
        Int b      = IntFrom(12345);
        Int result_value = IntInit();
    
        IntMul(&result_value, &a, &b);

In Int.Math.c:264:

    
        Int value = IntFrom(12345);
        Int result_value = IntInit();
    
        IntSquare(&result_value, &value);

In Int.Math.c:280:

        Int base = IntFrom(7);
        Int exponent = IntFrom(20);
        Int result_value = IntInit();
        Str text = StrInit();

In Int.Math.c:303:

    
        Int dividend  = IntFromStr("12345678901234567890");
        Int quotient  = IntInit();
        Int remainder = IntInit();
        Str qtext     = StrInit();

In Int.Math.c:304:

        Int dividend  = IntFromStr("12345678901234567890");
        Int quotient  = IntInit();
        Int remainder = IntInit();
        Str qtext     = StrInit();

In Int.Math.c:324:

    
        Int dividend = IntFrom(126);
        Int result_value = IntInit();
    
        IntDiv(&result_value, &dividend, 10u);

In Int.Math.c:339:

    
        Int dividend = IntFromStr("12345678901234567890");
        Int result_value = IntInit();
        Str text = StrInit();

In Int.Math.c:372:

    
        Int dividend = IntFromStr("12345678901234567890");
        Int quotient = IntInit();
        Int remainder = IntInit();
        Str text = StrInit();

In Int.Math.c:373:

        Int dividend = IntFromStr("12345678901234567890");
        Int quotient = IntInit();
        Int remainder = IntInit();
        Str text = StrInit();

In Int.Math.c:393:

    
        Int dividend = IntFrom(126);
        Int result_value = IntInit();
    
        IntMod(&result_value, &dividend, 10u);

In Int.Math.c:408:

    
        Int value = IntFromStr("12345678901234567890");
        Int remainder = IntInit();
    
        IntMod(&remainder, &value, 97u);

In Int.Math.c:423:

        Int a = IntFrom(48);
        Int b = IntFrom(18);
        Int result_value = IntInit();
    
        IntGCD(&result_value, &a, &b);

In Int.Math.c:440:

        Int a = IntFrom(21);
        Int b = IntFrom(6);
        Int result_value = IntInit();
    
        IntLCM(&result_value, &a, &b);

In Int.Math.c:456:

    
        Int value = IntFrom(4096);
        Int result_value = IntInit();
    
        IntRoot(&result_value, &value, 4);

In Int.Math.c:471:

    
        Int value = IntFrom(200);
        Int root = IntInit();
        Int remainder = IntInit();

In Int.Math.c:472:

        Int value = IntFrom(200);
        Int root = IntInit();
        Int remainder = IntInit();
    
        IntRootRem(&root, &remainder, &value, 3);

In Int.Math.c:489:

    
        Int value = IntFrom(200);
        Int result_value = IntInit();
    
        IntSqrt(&result_value, &value);

In Int.Math.c:504:

    
        Int value = IntFrom(200);
        Int root = IntInit();
        Int remainder = IntInit();

In Int.Math.c:505:

        Int value = IntFrom(200);
        Int root = IntInit();
        Int remainder = IntInit();
    
        IntSqrtRem(&root, &remainder, &value);

In Int.Math.c:572:

        Int value = IntFrom(12345);
        Int mod = IntFrom(97);
        Int result_value = IntInit();
    
        IntSquareMod(&result_value, &value, &mod);

In Int.Math.c:590:

        Int b = IntFrom(250);
        Int m = IntFrom(13);
        Int result_value = IntInit();
    
        IntModAdd(&result_value, &a, &b, &m);

In Int.Math.c:609:

        Int b = IntFrom(9);
        Int m = IntFrom(13);
        Int result_value = IntInit();
    
        IntModSub(&result_value, &a, &b, &m);

In Int.Math.c:628:

        Int b = IntFrom(456);
        Int m = IntFrom(97);
        Int result_value = IntInit();
    
        IntModMul(&result_value, &a, &b, &m);

In Int.Math.c:647:

        Int b = IntFrom(3);
        Int m = IntFrom(13);
        Int result_value = IntInit();
        Int check = IntInit();

In Int.Math.c:648:

        Int m = IntFrom(13);
        Int result_value = IntInit();
        Int check = IntInit();
    
        bool result = IntModDiv(&result_value, &a, &b, &m);

In Int.Math.c:669:

        Int base = IntFrom(7);
        Int mod = IntFrom(13);
        Int result_value = IntInit();
    
        IntPowMod(&result_value, &base, 20u, &mod);

In Int.Math.c:687:

        Int exp = IntFrom(13);
        Int mod = IntFrom(497);
        Int result_value = IntInit();
    
        IntPowMod(&result_value, &base, &exp, &mod);

In Int.Math.c:705:

        Int value = IntFrom(3);
        Int mod = IntFrom(11);
        Int result_value = IntInit();
        Int check = IntInit();

In Int.Math.c:706:

        Int mod = IntFrom(11);
        Int result_value = IntInit();
        Int check = IntInit();
    
        bool result = IntModInv(&result_value, &value, &mod);

In Int.Math.c:726:

        Int value = IntFrom(10);
        Int mod = IntFrom(13);
        Int root = IntInit();
        Int check = IntInit();

In Int.Math.c:727:

        Int mod = IntFrom(13);
        Int root = IntInit();
        Int check = IntInit();
    
        bool result = IntModSqrt(&root, &value, &mod);

In Int.Math.c:774:

    
        Int value = IntFromStr("1000000000");
        Int next = IntInit();
        Str text = StrInit();

In Int.Math.c:843:

    
        Int dividend  = IntFrom(1);
        Int divisor   = IntInit();
        Int quotient  = IntFrom(99);
        Int remainder = IntFrom(77);

In Int.Math.c:909:

        Int a            = IntFrom(10);
        Int b            = IntFrom(3);
        Int m            = IntInit();
        Int result_value = IntFrom(99);

In Int.Math.c:944:

    
        Int base = IntFrom(2);
        Int mod = IntInit();
        Int result_value = IntInit();

In Int.Math.c:945:

        Int base = IntFrom(2);
        Int mod = IntInit();
        Int result_value = IntInit();
    
        IntPowMod(&result_value, &base, 8u, &mod);

In Int.Math.c:956:

        Int base         = IntFrom(2);
        Int exp          = IntFrom(8);
        Int mod          = IntInit();
        Int result_value = IntFrom(99);

In Int.Type.c:14:

    
    bool test_int_init(void) {
        WriteFmt("Testing IntInit\n");
    
        Int value = IntInit();

In Int.Type.c:16:

        WriteFmt("Testing IntInit\n");
    
        Int value = IntInit();
    
        bool result = IntIsZero(&value);

In Int.Type.c:67:

        alloc.flags = 0x4B4Bu;
    
        Int original = IntInit(alloc);
        original.bits.allocator.state = (void *)&original;

In Init.h:25:

    
        value.negative    = false;
        value.significand = IntInit(alloc);
        value.exponent    = 0;
        return value;

Last updated on May 14, 2026

IntGT IntIsEven