How to avoid overflow in modular multiplication?

Last Updated : 14 Sep, 2023

Consider below simple method to multiply two numbers.

C++

#include <iostream>
using namespace std;
 
#define ll long long
 
// Function to multiply two numbers modulo mod
ll multiply(ll a, ll b, ll mod)
{
    // Multiply two numbers and then take modulo to prevent
    // overflow
    return ((a % mod) * (b % mod)) % mod;
}
 
int main()
{
    ll a = 12345678912345;
    ll b = 98765432198765;
    ll mod = 1000000007;
 
    cout << multiply(a, b, mod) << endl;
 
    return 0;
}

C

// A Simple solution that causes overflow when 
// value of (a % mod) * (b % mod) becomes more than
// maximum value of long long int 
#define ll long long
 
ll multiply(ll a, ll b, ll mod)
{
   return ((a % mod) * (b % mod)) % mod;
}

Java

// A Simple solution that causes overflow when 
// value of (a % mod) * (b % mod) becomes more than
// maximum value of long int 
 
 
static long multiply(long a, long b, long mod)
{
   return ((a % mod) * (b % mod)) % mod;
}
 
// This code contributed by gauravrajput1 

Python

# A python program to handle overflow
# when multiplying two numbers       
 
def multiply(a,b,mod):
    return ((a % mod) * (b % mod)) % mod;
 
# Code contributed by Gautam goel (gautamgoel962)

C#

// C# program to implement
// the above approach
using System;
 
class GFG{
     
 
// A Simple solution that causes overflow when
// value of (a % mod) * (b % mod) becomes more than
// maximum value of long int
static long multiply(long a, long b, long mod)
{
   return ((a % mod) * (b % mod)) % mod;
}
}
 
// This code is contributed by code_hunt.

Javascript

<script>
 
function multiply(a,b,mod)
{
    return ((a % mod) * (b % mod)) % mod;
}
 
 
// This code is contributed by rag2127
</script>

The above function works fine when multiplication doesn’t result in overflow. But if input numbers are such that the result of multiplication is more than maximum limit.
For example, the above method fails when mod = 10¹¹, a = 9223372036854775807 (largest long long int) and b = 9223372036854775807 (largest long long int). Note that there can be smaller values for which it may fail. There can be many more examples of smaller values. In fact any set of values for which multiplication can cause a value greater than maximum limit.
How to avoid overflow?
We can multiply recursively to overcome the difficulty of overflow. To multiply a*b, first calculate a*b/2 then add it twice. For calculating a*b/2 calculate a*b/4 and so on (similar to log n exponentiation algorithm).

// To compute (a * b) % mod
multiply(a,  b, mod)
1)  ll res = 0; // Initialize result
2)  a = a % mod.
3)  While (b > 0)
        a) If b is odd, then add 'a' to result.
               res = (res + a) % mod
        b) Multiply 'a' with 2
           a = (a * 2) % mod
        c) Divide 'b' by 2
           b = b/2  
4)  Return res

Below is the implementation.

C++

// C++ program for modular multiplication without
// any overflow
#include<iostream>
using namespace std;
 
typedef long long int ll;
 
// To compute (a * b) % mod
ll mulmod(ll a, ll b, ll mod)
{
    ll res = 0; // Initialize result
    a = a % mod;
    while (b > 0)
    {
        // If b is odd, add 'a' to result
        if (b % 2 == 1)
            res = (res + a) % mod;
 
        // Multiply 'a' with 2
        a = (a * 2) % mod;
 
        // Divide b by 2
        b /= 2;
    }
 
    // Return result
    return res % mod;
}
 
// Driver program
int main()
{
   ll a = 9223372036854775807, b = 9223372036854775807;
   cout << mulmod(a, b, 100000000000);
   return 0;
}

Java

// Java program for modular multiplication  
// without any overflow 
 
class GFG 
{
 
    // To compute (a * b) % mod 
    static long mulmod(long a, long b, 
                            long mod) 
    {
        long res = 0; // Initialize result 
        a = a % mod;
        while (b > 0)
        {
            // If b is odd, add 'a' to result 
            if (b % 2 == 1) 
            {
                res = (res + a) % mod;
            }
 
            // Multiply 'a' with 2 
            a = (a * 2) % mod;
 
            // Divide b by 2 
            b /= 2;
        }
 
        // Return result 
        return res % mod;
    }
 
    // Driver code 
    public static void main(String[] args)
    {
 
        long a = 9223372036854775807L, b = 9223372036854775807L;
        System.out.println(mulmod(a, b, 100000000000L));
    }
} 
 
// This code is contributed by Rajput-JI

Python3

# Python3 program for modular multiplication 
# without any overflow
 
# To compute (a * b) % mod
def mulmod(a, b, mod):
 
    res = 0; # Initialize result
    a = a % mod;
    while (b > 0):
     
        # If b is odd, add 'a' to result
        if (b % 2 == 1):
            res = (res + a) % mod;
 
        # Multiply 'a' with 2
        a = (a * 2) % mod;
 
        # Divide b by 2
        b //= 2;
 
    # Return result
    return res % mod;
 
# Driver Code
a = 9223372036854775807;
b = 9223372036854775807;
print(mulmod(a, b, 100000000000));
 
# This code is contributed by mits

C#

// C# program for modular multiplication 
// without any overflow 
using System;
 
class GFG 
{ 
 
// To compute (a * b) % mod 
static long mulmod(long a, long b, long mod) 
{ 
    long res = 0; // Initialize result 
    a = a % mod; 
    while (b > 0) 
    { 
        // If b is odd, add 'a' to result 
        if (b % 2 == 1) 
        { 
            res = (res + a) % mod; 
        } 
 
        // Multiply 'a' with 2 
        a = (a * 2) % mod; 
 
        // Divide b by 2 
        b /= 2; 
    } 
 
    // Return result 
    return res % mod; 
} 
 
// Driver code 
public static void Main(String[] args) 
{ 
    long a = 9223372036854775807L, 
         b = 9223372036854775807L; 
    Console.WriteLine(mulmod(a, b, 100000000000L)); 
} 
} 
 
// This code is contributed by 29AjayKumar

Javascript

<script>
// JavaScript program for modular multiplication 
// without any overflow
 
// To compute (a * b) % mod
function mulmod(a, b, mod){
    let res = 0; //Initialize result
    a = a % mod;
    while (b > 0){
        // If b is odd, add 'a' to result
        if (b % 2 == 1){
            res = (res + a) % mod;
        }
 
        // Multiply 'a' with 2
        a = (a * 2) % mod;
 
        // Divide b by 2
        b = Math.floor(b/2);
    }
     
    // Return result
    return res % mod;
}
 
 
// Driver Code
let a = 9223372036854775807;
let b = 9223372036854775807;
document.write(mulmod(a, b, 100000000000));
 
// This code is contributed by Gautam goel (gautamgoel962)
</script>

Output:

84232501249

Thanks to Utkarsh Trivedi for suggesting above solution.

RSA Algorithm in Cryptography

kartik

Improve

Article Tags :

Practice Tags :

How to avoid overflow in modular multiplication?

C++

C

Java

Python

C#

Javascript

C++

Java

Python3

C#

Javascript

Similar Reads

Basics of Number Theory

Modular Arithmetic

Number Theory

Game Theory

Practice Problems

Miscellaneous Practice Problems

Thank You!

What kind of Experience do you want to share?