Skip to content

IntModMul

Description

Compute (a * b) mod modulus.

Parameters

Name Direction Description
result out Destination for the reduced product
a in Left operand
b in Right operand
modulus in Modulus

Usage example (from documentation)

  IntModMul(&result, &a, &b, &modulus);

Success

Returns true. *result holds (a * b) mod modulus.

Failure

Returns false on modulus == 0 or allocator OOM. *result is left untouched.

Usage example (Cross-references)

Usage examples (Cross-references)
    }
    
    bool IntModMul(Int *result, const Int *a, const Int *b, const Int *modulus) {
        ValidateInt(result);
        ValidateInt(a);
        }
    
        if (!IntModMul(&value, a, &inverse, modulus)) {
            IntDeinit(&inverse);
            IntDeinit(&value);
    
    bool IntSquareMod(Int *result, const Int *value, const Int *modulus) {
        return IntModMul(result, value, value, modulus);
    }
                Int next = IntInit(IntAllocator(result));
    
                if (!IntModMul(&next, &acc, &base_mod, modulus)) {
                    IntDeinit(&acc);
                    IntDeinit(&base_mod);
                Int next = IntInit(IntAllocator(result));
    
                if (!IntModMul(&next, &base_mod, &base_mod, modulus)) {
                    IntDeinit(&acc);
                    IntDeinit(&base_mod);
                Int next = IntInit(IntAllocator(result));
    
                if (!IntModMul(&next, &acc, &base_mod, modulus)) {
                    IntDeinit(&acc);
                    IntDeinit(&base_mod);
                Int next = IntInit(IntAllocator(result));
    
                if (!IntModMul(&next, &base_mod, &base_mod, modulus)) {
                    IntDeinit(&acc);
                    IntDeinit(&base_mod);
                    }
    
                    if (!IntModMul(&next, &r, &b, modulus)) {
                        IntDeinit(&b);
                        IntDeinit(&b_sq);
                    }
                    next = IntInit(IntAllocator(result));
                    if (!IntModMul(&next, &t, &b_sq, modulus)) {
                        IntDeinit(&b);
                        IntDeinit(&b_sq);
    
    bool test_int_mod_mul(void) {
        WriteFmt("Testing IntModMul\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();
        Int result_value = IntInit(&alloc.base);
    
        IntModMul(&result_value, &a, &b, &m);
    
        bool result = IntToU64(&result_value) == 22;
        result      = result && (IntToU64(&result_value) == 12);
    
        IntModMul(&check, &result_value, &b, &m);
        result = result && (IntCompare(&check, 10) == 0);
        result      = result && (IntToU64(&result_value) == 4);
    
        IntModMul(&check, &value, &result_value, &mod);
        result = result && (IntToU64(&check) == 1);
Last updated on