## 1. Overview

Kotlin, just like Java, does not have an exponent operator. However, it has a *pow()* extension function that we can call on a *Float* or *Double*.

In this tutorial, we’ll see various ways of performing the exponent operation in Kotlin.

Let’s dive straightaway into the various ways we can calculate the power of a number in Kotlin.

### 2.1. Algorithmically Calculate the Power of a Number

One way we can achieve the power of a number in Kotlin is by developing an efficient algorithm that can help us achieve the desired results. Let’s take a look at a program that can do just that:

```
fun power(baseVal: Int, exponentVal: Int): Long {
val base = baseVal
var exponent = exponentVal
var result: Long = 1
while (exponent != 0) {
result *= base.toLong()
--exponent
}
return result
}
assertEquals(4, power(2,2))
assertEquals(1024, power(4, 5)
```

**Basically, we multiply the ***base* value by itself *exponent* number of times as long as it is not zero.

Another approach could be to calculate the power recursively:

```
fun power(baseVal: Int, exponentVal: Int): Long {
if (exponentVal != 0) {
return baseVal * power(baseVal, exponentVal - 1)
}
else {
return 1
}
}
assertEquals(4, power(2,2))
assertEquals(1024, power(4, 5)
```

### 2.2. Using *pow()* Extension Function

As mentioned earlier, the *pow()* function is an extension function that can only be called on a *Float* or *Double* object. What this means is that to use this function on an *Int *or* Long*, we need to convert it first to a *Double,* then back to *Int* or *Long* afterward:

```
val baseDouble = 5.0
val exponentDouble = 2.5
assertEquals(55.9016994375, baseDouble.pow(exponentDouble))
val baseInt = 3
val exponentInt = -4
assertEquals(0.012345679012345678, baseInt.toDouble().pow(exponentInt.toDouble()))
```

In the first assertion statement, we do not convert the values because they are of type *Double* and, as such, are qualified to call the *pow()* function. For the second assert statement, this is not the case since the values have a type *Int*.

### 2.3. Using *Math.pow()* Function

Another interesting way we can calculate the power of a number is by using the *Math.pow()* function. Albeit this is originally a Java function from the *java.lang* library, we can still make use of this function in Kotlin:

```
assertEquals(55.90169943749474, Math.pow(5.0, 2.5))
assertEquals(0.012345679012345678, Math.pow(3.0, -4.0))
```

We notice that this function accepts parameters of type *Double* too. So, if we need to call this function on an *Int* or *Long*, we need to convert them to a *Double* first:

```
val baseInt = 3
val exponentInt = -4
assertEquals(0.012345679012345678, Math.pow(baseInt.toDouble(), exponentInt.toDouble()))
```

## 3. Conclusion

In this tutorial, we have seen several ways we can perform power operations on a Number in Kotlin. We also notice that other than the algorithmic approach, performing the power operation using the *pow()* or *Math.pow()* functions requires parameters of type *Double* or *Float*.

As usual, all code samples are available over on GitHub.