## ModPow Method in Programming – Java

In computer programming, modular exponentiation, or modpow for short, is a common operation used in cryptography and other mathematical applications. It involves calculating the remainder of a number raised to a power modulo another number, where the modulo operation returns the remainder of the division of the first number by the second number. This article will explore modpow in programming and provide examples using the Java programming language.

### Modular Exponentiation (ModPow)

To understand modpow, we first need to understand modular exponentiation. Suppose we have two integers, `a`

and `b`

, and a positive integer `n`

. We want to calculate `a^b mod n`

, which is the remainder when `a^b`

is divided by n. One way to calculate this is to use repeated multiplication:

```
result = 1
for i from 1 to b:
result = (result * a) % n
```

This code iteratively multiplies a by itself b times, taking the result modulo n at each step to ensure that the intermediate values do not become too large. However, this approach can be slow for large values of b. Modular Exponentiation using Exponentiation by Squaring A faster approach to modular exponentiation is to use the exponentiation by squaring algorithm. This algorithm is based on the observation that a^(2k) = (a^k)^2 and a^(2k+1) = a * (a^k)^2. Using this observation, we can compute a^b mod n recursively:

```
function modpow(a, b, n):
if b == 0:
return 1
else if b % 2 == 0:
temp = modpow(a, b/2, n)
return (temp * temp) % n
else:
temp = modpow(a, (b-1)/2, n)
return (a * temp * temp) % n
```

This code first checks if b is zero, in which case it returns 1. If b is even, it recursively computes (a^(b/2))^2 and returns the result modulo n. If b is odd, it computes a * (a^((b-1)/2))^2 recursively and returns the result modulo n. This approach reduces the number of multiplications required to calculate the result of a^b mod n, making it more efficient for large values of b. Example using Java In Java, we can implement the modpow function using the exponentiation by squaring algorithm as follows:

```
public static int modpow(int a, int b, int n) {
if (b == 0) {
return 1;
} else if (b % 2 == 0) {
int temp = modpow(a, b/2, n);
return (temp * temp) % n;
} else {
int temp = modpow(a, (b-1)/2, n);
return (a * temp * temp) % n;
}
}
```

This code defines a static method called modpow that takes three integer arguments: a, b, and n. It returns the value of a^b mod n using the exponentiation by squaring algorithm. Here’s an example usage of this method:

```
int a = 3;
int b = 13;
int n = 7;
int result = modpow(a, b, n);
System.out.println(result); // prints 5
```

In this example, we calculate the remainder of 3^13 when divided by 7 using modpow. The result is 5.