IntMod

Documentation

API Reference

IntMod

Description

Generic modulo convenience macro.

Parameters

Name	Direction	Description
`result`	out	Destination for the remainder
`dividend`	in	Dividend
`divisor`	in	Divisor selected through generic dispatch

Usage example (from documentation)

  IntMod(&remainder, &value, 97u);

Usage example (Cross-references)

Usage examples (Cross-references)

In Int.c:1081:

    }
    
    void(IntMod)(Int *result, Int *dividend, Int *divisor) {
        Int quotient  = IntInit();
        Int remainder = IntInit();

In Int.c:1129:

            Int r = IntInit();
    
            IntMod(&r, &x, &y);
            IntDeinit(&x);
            x = y;

In Int.c:1335:

        int result = 1;
    
        IntMod(&aa, a, &nn);
    
        while (!IntIsZero(&aa)) {

In Int.c:1354:

            }
    
            IntMod(&aa, &aa, &nn);
        }

In Int.c:1381:

        Int sum = IntInit();
    
        IntMod(&ar, a, modulus);
        IntMod(&br, b, modulus);
        IntAdd(&sum, &ar, &br);

In Int.c:1382:

    
        IntMod(&ar, a, modulus);
        IntMod(&br, b, modulus);
        IntAdd(&sum, &ar, &br);
        IntMod(result, &sum, modulus);

In Int.c:1384:

        IntMod(&br, b, modulus);
        IntAdd(&sum, &ar, &br);
        IntMod(result, &sum, modulus);
    
        IntDeinit(&ar);

In Int.c:1404:

        Int br = IntInit();
    
        IntMod(&ar, a, modulus);
        IntMod(&br, b, modulus);

In Int.c:1405:

    
        IntMod(&ar, a, modulus);
        IntMod(&br, b, modulus);
    
        if (IntGE(&ar, &br)) {

In Int.c:1441:

        Int prod = IntInit();
    
        IntMod(&ar, a, modulus);
        IntMod(&br, b, modulus);
        IntMul(&prod, &ar, &br);

In Int.c:1442:

    
        IntMod(&ar, a, modulus);
        IntMod(&br, b, modulus);
        IntMul(&prod, &ar, &br);
        IntMod(result, &prod, modulus);

In Int.c:1444:

        IntMod(&br, b, modulus);
        IntMul(&prod, &ar, &br);
        IntMod(result, &prod, modulus);
    
        IntDeinit(&ar);

In Int.c:1495:

        Int base_mod = IntInit();
    
        IntMod(&acc, &acc, modulus);
        IntMod(&base_mod, base, modulus);

In Int.c:1496:

    
        IntMod(&acc, &acc, modulus);
        IntMod(&base_mod, base, modulus);
    
        while (exponent > 0) {

In Int.c:1535:

        Int exp      = IntClone(exponent);
    
        IntMod(&acc, &acc, modulus);
        IntMod(&base_mod, base, modulus);

In Int.c:1536:

    
        IntMod(&acc, &acc, modulus);
        IntMod(&base_mod, base, modulus);
    
        while (!IntIsZero(&exp)) {

In Int.c:1587:

        bool      ok      = false;
    
        IntMod(&reduced, value, modulus);
        new_r = IntClone(&reduced);

In Int.c:1620:

            Int mag_mod   = IntInit();
    
            IntMod(&mag_mod, &t.magnitude, modulus);
            if (t.negative && !IntIsZero(&mag_mod)) {
                (void)IntSub(&positive, modulus, &mag_mod);

In Int.c:1624:

                (void)IntSub(&positive, modulus, &mag_mod);
            } else {
                IntMod(&positive, &t.magnitude, modulus);
            }

In Int.c:1653:

        bool ok = false;
    
        IntMod(&a, value, modulus);
    
        if (IntIsZero(&a)) {

In Int.Math.c:390:

    
    bool test_int_mod(void) {
        WriteFmt("Testing IntMod generic dispatch\n");
    
        Int dividend = IntFrom(126);

In Int.Math.c:395:

        Int result_value = IntInit();
    
        IntMod(&result_value, &dividend, 10u);
    
        bool result = IntToU64(&result_value) == 6;

In Int.Math.c:405:

    
    bool test_int_mod_scalar(void) {
        WriteFmt("Testing IntMod scalar-divisor dispatch\n");
    
        Int value = IntFromStr("12345678901234567890");

In Int.Math.c:410:

        Int remainder = IntInit();
    
        IntMod(&remainder, &value, 97u);
    
        IntDeinit(&value);

In Int.Math.c:873:

    
    bool test_int_mod_scalar_zero_modulus(void) {
        WriteFmt("Testing IntMod scalar zero-modulus handling\n");
    
        Int value = IntFrom(10);

In Int.Math.c:878:

        Int result_value = IntInit();
    
        IntMod(&result_value, &value, 0u);
        return false;
    }

In Math.h:150:

    /// TAGS: Int, Math, Modulo
    ///
    void (IntMod)(Int *result, Int *dividend, Int *divisor);
    ///
    /// Compute quotient and remainder in one call.

In Math.h:543:

                (divisor),                                                                                                 \
                Int: MISRA_PRIV_IntModValue,                                                                               \
                Int *: IntMod,                                                                                             \
                const Int *: MISRA_PRIV_IntModConst,                                                                       \
                unsigned char: MISRA_PRIV_IntModU64Into,                                                                   \

Last updated on April 20, 2026

IntLT IntModAdd