Skip to content

IntSquareMod

Description

Compute (value^2) mod modulus.

Parameters

Name Direction Description
result out Destination for the reduced square
value in Value to square
modulus in Modulus

Usage example (from documentation)

  IntSquareMod(&result, &value, &modulus);

Success

Returns true. *result holds (value * value) mod modulus.

Failure

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

Usage example (Cross-references)

Usage examples (Cross-references)
    }
    
    bool IntSquareMod(Int *result, const Int *value, const Int *modulus) {
        return IntModMul(result, value, value, modulus);
    }
                    Int next = IntInit(IntAllocator(result));
    
                    if (!IntSquareMod(&next, &t_power, modulus)) {
                        IntDeinit(&next);
                        IntDeinit(&t_power);
                        Int square = IntInit(IntAllocator(result));
    
                        if (!IntSquareMod(&square, &b, modulus)) {
                            IntDeinit(&square);
                            IntDeinit(&b);
                    r = next;
    
                    if (!IntSquareMod(&b_sq, &b, modulus)) {
                        IntDeinit(&b);
                        IntDeinit(&b_sq);
                        Int next = IntInit(IntAllocator(value));
    
                        if (!IntSquareMod(&next, &x, value)) {
                            IntDeinit(&next);
                            IntDeinit(&base);
    
    bool test_int_square_mod(void) {
        WriteFmt("Testing IntSquareMod\n");
    
        DefaultAllocator alloc = DefaultAllocatorInit();
        Int result_value = IntInit(&alloc.base);
    
        IntSquareMod(&result_value, &value, &mod);
    
        bool result = IntToU64(&result_value) == 94;
    
        bool result = IntModSqrt(&root, &value, &mod);
        IntSquareMod(&check, &root, &mod);
        result = result && (IntCompare(&check, 10) == 0);
Last updated on