Modular Exponentiation of Complex Numbers

Given four integers A, B, K, M. The task is to find (A + iB)K % M which is a complex number too. A + iB represents a complex number.

Examples:

Input : A = 2, B = 3, K = 4, M = 5
Output: 1 + i*0

Input : A = 7, B = 3, K = 10, M = 97
Output: 25 + i*29

Prerequisite: Modular Exponentiation

Approach:
An efficient approach is similar to the modular exponentiation of a single number. Here, instead of a single we have two number A, B. So, pass a pair of integers as a parameter to the function instead of a single number.

Below is the implementation of the above approach :

C++

filter_none

edit
close

play_arrow

link
brightness_4
code

#include <bits/stdc++.h>
using namespace std;
  
// Function to multiply two complex numbers modulo M
pair<int, int> Multiply (pair<int, int> p, pair<int, int> q,
                                                    int M)
{
    // Multiplication of two complex numbers is 
    // (a + ib)(c + id) = (ac - bd) + i(ad + bc)
      
    int x = ((p.first * q.first) % M - (p.second * 
                                    q.second) % M + M) % M;
      
    int y = ((p.first * q.second) % M + (p.second * 
                                          q.first) % M) %M;
  
    // Return the multiplied value
    return {x, y};
}
  
  
// Function to calculate the complex modular exponentiation
pair<int, int> compPow(pair<int, int> complex, int k, int M)
{
    // Here, res is initialised to (1 + i0)
    pair<int, int> res = { 1, 0 }; 
      
    while (k > 0) 
    {
        // If k is odd
        if (k & 1)
        {
            // Multiply 'complex' with 'res'
            res = Multiply(res, complex, M); 
        }
          
        // Make complex as complex*complex
        complex = Multiply(complex, complex, M);
          
        // Make k as k/2
        k = k >> 1; 
    }
      
    //Return the required answer
    return res;
}
  
// Driver code
int main()
{
  
    int A = 7, B = 3, k = 10, M = 97;
      
    // Function call
    pair<int, int> ans = compPow({A, B}, k, M);
      
    cout << ans.first << " + i" << ans.second;    
      
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.*;
  
class GFG 
{
static class pair 
    int first, second; 
    public pair(int first, int second) 
    
        this.first = first; 
        this.second = second; 
    
  
// Function to multiply two complex numbers modulo M
static pair Multiply (pair p, pair q, int M)
{
    // Multiplication of two complex numbers is 
    // (a + ib)(c + id) = (ac - bd) + i(ad + bc)
      
    int x = ((p.first * q.first) % M -
             (p.second * q.second) % M + M) % M;
      
    int y = ((p.first * q.second) % M + 
             (p.second * q.first) % M) % M;
  
    // Return the multiplied value
    return new pair(x, y);
}
  
  
// Function to calculate the 
// complex modular exponentiation
static pair compPow(pair complex, int k, int M)
{
    // Here, res is initialised to (1 + i0)
    pair res = new pair(1, 0 ); 
      
    while (k > 0
    {
        // If k is odd
        if (k % 2 == 1)
        {
            // Multiply 'complex' with 'res'
            res = Multiply(res, complex, M); 
        }
          
        // Make complex as complex*complex
        complex = Multiply(complex, complex, M);
          
        // Make k as k/2
        k = k >> 1
    }
      
    // Return the required answer
    return res;
}
  
// Driver code
public static void main(String[] args)
{
    int A = 7, B = 3, k = 10, M = 97;
      
    // Function call
    pair ans = compPow(new pair(A, B), k, M);
      
    System.out.println(ans.first + " + i"
                       ans.second); 
}
}
  
// This code is contributed by PrinciRaj1992

chevron_right


Python3

# Python3 implementation of the approach

# Function to multiply two complex numbers modulo M
def Multiply (p, q, M):

# Multiplication of two complex numbers is
# (a + ib)(c + id) = (ac – bd) + i(ad + bc)
x = ((p[0] * q[0]) % M – \
(p[1] * q[1]) % M + M) % M

y = ((p[0] * q[1]) % M + \
(p[1] * q[0]) % M) %M

# Return the multiplied value
return [x, y]

# Function to calculate the
# complex modular exponentiation
def compPow(complex, k, M):

# Here, res is initialised to (1 + i0)
res = [1, 0]

while (k > 0):

# If k is odd
if (k & 1):

# Multiply ‘complex’ with ‘res’
res = Multiply(res, complex, M)

# Make complex as complex*complex
complex = Multiply(complex, complex, M)

# Make k as k/2
k = k >> 1

# Return the required answer
return res

# Driver code
if __name__ == ‘__main__’:
A = 7
B = 3
k = 10
M = 97

# Function call
ans = compPow([A, B], k, M)

print(ans[0], “+ i”, end = “”)
print(ans[1])

# This code is contributed by
# Surendra_Gangwar

C#

filter_none

edit
close

play_arrow

link
brightness_4
code

// C# implementation of the approach
using System;
      
class GFG 
{
public class pair 
    public int first, second; 
    public pair(int first, int second) 
    
        this.first = first; 
        this.second = second; 
    
  
// Function to multiply two complex numbers modulo M
static pair Multiply (pair p, pair q, int M)
{
    // Multiplication of two complex numbers is 
    // (a + ib)(c + id) = (ac - bd) + i(ad + bc)
      
    int x = ((p.first * q.first) % M -
             (p.second * q.second) % M + M) % M;
      
    int y = ((p.first * q.second) % M + 
             (p.second * q.first) % M) % M;
  
    // Return the multiplied value
    return new pair(x, y);
}
  
  
// Function to calculate the 
// complex modular exponentiation
static pair compPow(pair complex, int k, int M)
{
    // Here, res is initialised to (1 + i0)
    pair res = new pair(1, 0 ); 
      
    while (k > 0) 
    {
        // If k is odd
        if (k % 2 == 1)
        {
            // Multiply 'complex' with 'res'
            res = Multiply(res, complex, M); 
        }
          
        // Make complex as complex*complex
        complex = Multiply(complex, complex, M);
          
        // Make k as k/2
        k = k >> 1; 
    }
      
    // Return the required answer
    return res;
}
  
// Driver code
public static void Main(String[] args)
{
    int A = 7, B = 3, k = 10, M = 97;
      
    // Function call
    pair ans = compPow(new pair(A, B), k, M);
      
    Console.WriteLine(ans.first + " + i"
                      ans.second); 
}
}
  
// This code is contributed by 29AjayKumar

chevron_right


Output:

25 + i29

Time complexity: O(log k).



My Personal Notes arrow_drop_up

Jadavpur University IT 22

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.