IntPowMod

Documentation

API Reference

IntPowMod

Description

Generic modular exponentiation convenience macro.

Parameters

Name	Direction	Description
`result`	out	Destination for the reduced power
`base`	in	Base value
`exponent`	in	Exponent selected through generic dispatch
`modulus`	in	Modulus

Usage example (from documentation)

  IntPowMod(&result, &base, 65537u, &modulus);

Usage example (Cross-references)

Usage examples (Cross-references)

In Int.c:1521:

    }
    
    void(IntPowMod)(Int *result, Int *base, Int *exponent, Int *modulus) {
        ValidateInt(result);
        ValidateInt(base);

In Int.c:1679:

            MISRA_PRIV_IntAddU64(&exponent, &exponent, 1);
            IntShiftRight(&exponent, 2);
            IntPowMod(&root, &a, &exponent, modulus);
    
            IntDeinit(&exponent);

In Int.c:1706:

            }
    
            IntPowMod(&c, &z, &q, modulus);
            IntPowMod(&t, &a, &q, modulus);

In Int.c:1707:

    
            IntPowMod(&c, &z, &q, modulus);
            IntPowMod(&t, &a, &q, modulus);
    
            exponent = IntClone(&q);

In Int.c:1712:

            MISRA_PRIV_IntAddU64(&exponent, &exponent, 1);
            IntShiftRight(&exponent, 1);
            IntPowMod(&r, &a, &exponent, modulus);
    
            while (MISRA_PRIV_IntCompareU64(&t, 1) != 0) {

In Int.c:1833:

                }
    
                IntPowMod(&x, &base, &d, value);
                if ((MISRA_PRIV_IntCompareU64(&x, 1) == 0) || IntEQ(&x, &n_minus_one)) {
                    IntDeinit(&base);

In Int.Math.c:665:

    
    bool test_int_pow_mod_scalar(void) {
        WriteFmt("Testing IntPowMod scalar-exponent dispatch\n");
    
        Int base = IntFrom(7);

In Int.Math.c:671:

        Int result_value = IntInit();
    
        IntPowMod(&result_value, &base, 20u, &mod);
    
        bool result = IntToU64(&result_value) == 3;

In Int.Math.c:682:

    
    bool test_int_pow_mod_integer_exponent(void) {
        WriteFmt("Testing IntPowMod Int-exponent dispatch\n");
    
        Int base = IntFrom(4);

In Int.Math.c:689:

        Int result_value = IntInit();
    
        IntPowMod(&result_value, &base, &exp, &mod);
    
        bool result = IntToU64(&result_value) == 445;

In Int.Math.c:905:

    
    bool test_int_pow_mod_scalar_zero_modulus(void) {
        WriteFmt("Testing IntPowMod scalar-exponent zero modulus handling\n");
    
        Int base = IntFrom(2);

In Int.Math.c:911:

        Int result_value = IntInit();
    
        IntPowMod(&result_value, &base, 8u, &mod);
        return false;
    }

In Int.Math.c:916:

    
    bool test_int_pow_mod_integer_zero_modulus(void) {
        WriteFmt("Testing IntPowMod Int-exponent zero modulus handling\n");
    
        Int base = IntFrom(2);

In Int.Math.c:923:

        Int result_value = IntInit();
    
        IntPowMod(&result_value, &base, &exp, &mod);
        return false;
    }

In Math.h:371:

    /// TAGS: Int, Math, Modular, Power
    ///
    void (IntPowMod)(Int *result, Int *base, Int *exponent, Int *modulus);
    ///
    /// Compute the multiplicative inverse of a value modulo `modulus`.

In Math.h:579:

                (exponent),                                                                                                \
                Int: MISRA_PRIV_IntPowModValue,                                                                            \
                Int *: IntPowMod,                                                                                          \
                const Int *: MISRA_PRIV_IntPowModConst,                                                                    \
                unsigned char: MISRA_PRIV_IntPowU64Mod,                                                                    \

Last updated on April 20, 2026

IntPow IntRoot