问题
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!
回答1:
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
回答2:
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)))
回答3:
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.
回答4:
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.
回答5:
little detail more
infix operator ^^ { associativity left precedence 160 }
func ^^ (radix: Int, power: Int) -> Int {
return Int(pow(CGFloat(radix), CGFloat(power)))
}
swift - Binary Expressions
回答6:
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
回答7:
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.
回答8:
Or just :
var a:Int = 3
var b:Int = 3
println(pow(Double(a),Double(b)))
回答9:
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
回答10:
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.
回答11:
To calculate power(2, n), simply use:
let result = 2 << (n-1)
回答12:
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
}
回答13:
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.
回答14:
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
}
}
回答15:
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
回答16:
func calc (base:Int, number:Int) -> Int {
var answer : Int = base
for _ in 2...number {answer *= base }
return answer
}
Example:
calc (2,2)
来源：https://stackoverflow.com/questions/24196689/how-to-get-the-power-of-some-integer-in-swift-language