# How to get the Power of some Integer in Swift language?

IntegerDoubleSwiftPow## Integer Problem Overview

I'm learning swift recently, but I have a basic problem that can't find an answer

I want to get something like

```
var a:Int = 3
var b:Int = 3
println( pow(a,b) ) // 27
```

but the pow function can work with double number only, it doesn't work with integer, and I can't even cast the int to double by something like Double(a) or a.double()...

Why it doesn't supply the power of integer? it will definitely return an integer without ambiguity ! and Why I can't cast a integer to a double? it just change 3 to 3.0 (or 3.00000... whatever)

if I got two integer and I want to do the power operation, how can I do it smoothly?

Thanks!

## Integer Solutions

## Solution 1 - Integer

If you like, you could declare an `infix`

`operator`

to do it.

```
// Put this at file level anywhere in your project
infix operator ^^ { associativity left precedence 160 }
func ^^ (radix: Int, power: Int) -> Int {
return Int(pow(Double(radix), Double(power)))
}
// ...
// Then you can do this...
let i = 2 ^^ 3
// ... or
println("2³ = \(2 ^^ 3)") // Prints 2³ = 8
```

I used two carets so you can still use the XOR operator.

**Update for Swift 3**

In Swift 3 the "magic number" `precedence`

is replaced by `precedencegroups`

:

```
precedencegroup PowerPrecedence { higherThan: MultiplicationPrecedence }
infix operator ^^ : PowerPrecedence
func ^^ (radix: Int, power: Int) -> Int {
return Int(pow(Double(radix), Double(power)))
}
// ...
// Then you can do this...
let i2 = 2 ^^ 3
// ... or
print("2³ = \(2 ^^ 3)") // Prints 2³ = 8
```

## Solution 2 - Integer

Other than that your variable declarations have syntax errors, this works exactly how you expected it to. All you have to do is cast `a`

and `b`

to Double and pass the values to `pow`

. Then, if you're working with 2 Ints and you want an Int back on the other side of the operation, just cast back to Int.

```
import Darwin
let a: Int = 3
let b: Int = 3
let x: Int = Int(pow(Double(a),Double(b)))
```

## Solution 3 - Integer

Sometimes, casting an `Int`

to a `Double`

is not a viable solution. At some magnitudes there is a loss of precision in this conversion. For example, the following code does not return what you might intuitively expect.

```
Double(Int.max - 1) < Double(Int.max) // false!
```

If you need **precision at high magnitudes** and don't need to worry about **negative exponents** — which can't be generally solved with integers anyway — then this implementation of the tail-recursive exponentiation-by-squaring algorithm is your best bet. According to this SO answer, this is "the standard method for doing modular exponentiation for huge numbers in asymmetric cryptography."

```
// using Swift 5.0
func pow<T: BinaryInteger>(_ base: T, _ power: T) -> T {
func expBySq(_ y: T, _ x: T, _ n: T) -> T {
precondition(n >= 0)
if n == 0 {
return y
} else if n == 1 {
return y * x
} else if n.isMultiple(of: 2) {
return expBySq(y, x * x, n / 2)
} else { // n is odd
return expBySq(y * x, x * x, (n - 1) / 2)
}
}
return expBySq(1, base, power)
}
```

Note: in this example I've used a generic `T: BinaryInteger`

. This is so you can use `Int`

or `UInt`

or any other integer-like type.

## Solution 4 - Integer

**If you really want an 'Int only' implementation and don't want to coerce to/from Double**, you'll need to implement it. Here is a trivial implementation; there are faster algorithms but this will work:

```
func pow (_ base:Int, _ power:UInt) -> Int {
var answer : Int = 1
for _ in 0..<power { answer *= base }
return answer
}
> pow (2, 4)
$R3: Int = 16
> pow (2, 8)
$R4: Int = 256
> pow (3,3)
$R5: Int = 27
```

In a real implementation you'd probably want some error checking.

## Solution 5 - Integer

The other answers are great but if preferred, you can also do it with an `Int`

extension so long as the exponent is positive.

```
extension Int {
func pow(toPower: Int) -> Int {
guard toPower > 0 else { return 0 }
return Array(repeating: self, count: toPower).reduce(1, *)
}
}
2.pow(toPower: 8) // returns 256
```

## Solution 6 - Integer

If you're disinclined towards operator overloading (although the `^^`

solution is probably clear to someone reading your code) you can do a quick implementation:

```
let pwrInt:(Int,Int)->Int = { a,b in return Int(pow(Double(a),Double(b))) }
pwrInt(3,4) // 81
```

## Solution 7 - Integer

little detail more

```
infix operator ^^ { associativity left precedence 160 }
func ^^ (radix: Int, power: Int) -> Int {
return Int(pow(CGFloat(radix), CGFloat(power)))
}
```

## Solution 8 - Integer

Or just :

```
var a:Int = 3
var b:Int = 3
println(pow(Double(a),Double(b)))
```

## Solution 9 - Integer

mklbtz is correct about exponentiation by squaring being the standard algorithm for computing integer powers, but the tail-recursive implementation of the algorithm seems a bit confusing. See http://www.programminglogic.com/fast-exponentiation-algorithms/ for a non-recursive implementation of exponentiation by squaring in C. I've attempted to translate it to Swift here:

```
func expo(_ base: Int, _ power: Int) -> Int {
var result = 1
while (power != 0){
if (power%2 == 1){
result *= base
}
power /= 2
base *= base
}
return result
}
```

Of course, this could be fancied up by creating an overloaded operator to call it and it could be re-written to make it more generic so it worked on anything that implemented the `IntegerType`

protocol. To make it generic, I'd probably start with something like

```
func expo<T:IntegerType>(_ base: T, _ power: T) -> T {
var result : T = 1
```

But, that is probably getting carried away.

## Solution 10 - Integer

It turns out you can also use `pow()`

. For example, you can use the following to express 10 to the 9th.

```
pow(10, 9)
```

Along with `pow`

, `powf()`

returns a `float`

instead of a `double`

. I have only tested this on Swift 4 and macOS 10.13.

## Solution 11 - Integer

Combining the answers into an overloaded set of functions (and using "**" instead of "^^" as some other languages use - clearer to me):

```
// http://stackoverflow.com/questions/24196689/how-to-get-the-power-of-some-integer-in-swift-language
// Put this at file level anywhere in your project
infix operator ** { associativity left precedence 160 }
func ** (radix: Double, power: Double) -> Double { return pow(radix, power) }
func ** (radix: Int, power: Int ) -> Double { return pow(Double(radix), Double(power)) }
func ** (radix: Float, power: Float ) -> Double { return pow(Double(radix), Double(power)) }
```

When using Float, you may lose precision. If using numeric literals and a mix of integers and non-integers, you will end up with Double by default. I personally like the ability to use a mathematical expression instead of a function like pow(a, b) for stylistic/readability reasons, but that's just me.

Any operators that would cause pow() to throw an error will also cause these functions to throw an error, so the burden of error checking still lies with the code using the power function anyway. KISS, IMHO.

Using the native pow() function allows to eg take square roots (2 ** 0.5) or inverse (2 ** -3 = 1/8). Because of the possibility to use inverse or fractional exponents, I wrote all my code to return the default Double type of the pow() function, which should return the most precision (if I remember the documentation correctly). If needed, this can be type-casted down to Int or Float or whatever, possibly with the loss of precision.

```
2 ** -3 = 0.125
2 ** 0.5 = 1.4142135623731
2 ** 3 = 8
```

## Solution 12 - Integer

To calculate `power(2, n)`

, simply use:

```
let result = 2 << (n-1)
```

## Solution 13 - Integer

**Swift 4.x version**

```
precedencegroup ExponentiationPrecedence {
associativity: right
higherThan: MultiplicationPrecedence
}
infix operator ^^: ExponentiationPrecedence
public func ^^ (radix: Float, power: Float) -> Float {
return pow((radix), (power))
}
public func ^^ (radix: Double, power: Double) -> Double {
return pow((radix), (power))
}
public func ^^ (radix: Int, power: Int) -> Int {
return NSDecimalNumber(decimal: pow(Decimal(radix), power)).intValue
}
```

## Solution 14 - Integer

In Swift 5:

```
extension Int{
func expo(_ power: Int) -> Int {
var result = 1
var powerNum = power
var tempExpo = self
while (powerNum != 0){
if (powerNum%2 == 1){
result *= tempExpo
}
powerNum /= 2
tempExpo *= tempExpo
}
return result
}
}
```

Use like this

```
2.expo(5) // pow(2, 5)
```

Thanks to @Paul Buis's answer.

## Solution 15 - Integer

Array(repeating: a, count: b).reduce(1, *)

## Solution 16 - Integer

An Int-based pow function that computes the value directly via bit shift for base 2 in Swift 5:

```
func pow(base: Int, power: UInt) -> Int {
if power == 0 { return 1 }
// for base 2, use a bit shift to compute the value directly
if base == 2 { return 2 << Int(power - 1) }
// otherwise multiply base repeatedly to compute the value
return repeatElement(base, count: Int(power)).reduce(1, *)
}
```

(Make sure the result is within the range of Int - this does not check for the out of bounds case)

## Solution 17 - Integer

Trying to combine the overloading, I tried to use generics but couldn't make it work. I finally figured to use NSNumber instead of trying to overload or use generics. This simplifies to the following:

```
typealias Dbl = Double // Shorter form
infix operator ** {associativity left precedence 160}
func ** (lhs: NSNumber, rhs: NSNumber) -> Dbl {return pow(Dbl(lhs), Dbl(rhs))}
```

The following code is the same function as above but implements error checking to see if the parameters can be converted to Doubles successfully.

```
func ** (lhs: NSNumber, rhs: NSNumber) -> Dbl {
// Added (probably unnecessary) check that the numbers converted to Doubles
if (Dbl(lhs) ?? Dbl.NaN) != Dbl.NaN && (Dbl(rhs) ?? Dbl.NaN) != Dbl.NaN {
return pow(Dbl(lhs), Dbl(rhs))
} else {
return Double.NaN
}
}
```

## Solution 18 - Integer

**Swift 5**

I was surprised, but I didn't find a proper correct solution here.

This is mine:

```
enum CustomMath<T: BinaryInteger> {
static func pow(_ base: T, _ power: T) -> T {
var tempBase = base
var tempPower = power
var result: T = 1
while (power != 0) {
if (power % 2 == 1) {
result *= base
}
tempPower = tempPower >> 1
tempBase *= tempBase
}
return result
}
}
```

Example:

```
CustomMath.pow(1,1)
```

## Solution 19 - Integer

I like this better

```
func ^ (left:NSNumber, right: NSNumber) -> NSNumber {
return pow(left.doubleValue,right.doubleValue)
}
var a:NSNumber = 3
var b:NSNumber = 3
println( a^b ) // 27
```

## Solution 20 - Integer

```
func calc (base:Int, number:Int) -> Int {
var answer : Int = base
for _ in 2...number {answer *= base }
return answer
}
```

Example:

```
calc (2,2)
```