Swift言語で整数の力を得る方法は？

私は最近素早く学習していますが、答えが見つからないという基本的な問題があります

私は何かを得たいです

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

しかし、pow関数は倍精度数でのみ機能し、整数では機能しません。また、Double（a）やa.double（）などの方法でintをdoubleにキャストすることもできません...

なぜそれは整数の力を供給しないのですか？それは間違いなく曖昧さのない整数を返します！なぜ整数をdoubleにキャストできないのですか？3を3.0に変更します（または3.00000 ...何でも）

2つの整数を取得して電源操作を実行したい場合、どうすればスムーズに実行できますか？

ありがとう！

必要に応じて、infix operatorそれを実行するように宣言できます。

// 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

XOR演算子を引き続き使用できるように、2つのキャレットを使用しました。

Swift 3のアップデート

Swift 3では、「マジックナンバー」precedenceは次のように置き換えられ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

変数宣言に構文エラーがあることを除いて、これは期待どおりに機能します。あなたがしなければならないのは、キャストaしbてDoubleに値を渡し、値をに渡すことだけですpow。次に、2つのIntを使用していて、操作の反対側でIntを戻したい場合は、Intにキャストバックします。

import Darwin 

let a: Int = 3
let b: Int = 3

let x: Int = Int(pow(Double(a),Double(b)))

IntへのキャストDoubleは、実行可能なソリューションではない場合があります。大きさによっては、この変換の精度が失われます。たとえば、次のコードは、直感的に期待できるものを返しません。

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

大規模な精度が必要であり、負の指数について心配する必要がない場合は、通常、整数では解決できません。この場合、テール再帰的二乗指数アルゴリズムのこの実装が最善の策です。このSOの回答によれば、これは「非対称暗号で膨大な数のモジュラ指数を行うための標準的な方法」です。

// 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) 
}

注：この例では、一般的なを使用しましたT: BinaryInteger。これによりInt、UIntまたはその他の整数のような型を使用できます。

「Intのみ」の実装が本当に必要で、/への強制を望まないDouble場合は、実装する必要があります。これは簡単な実装です。より速いアルゴリズムがありますが、これはうまくいきます：

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

実際の実装では、おそらくいくつかのエラーチェックが必要になります。

少し詳細

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

swift-バイナリ式

演算子のオーバーロードに気が進まない場合（^^ソリューションがコードを読んでいる人にはおそらく明らかであるとしても）、すばやく実装できます。

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

mklbtzは、整数の累乗を計算するための標準アルゴリズムである2乗により、べき乗について正しいですが、アルゴリズムの末尾再帰実装は少し混乱しているようです。Cで二乗することによる指数の非再帰的な実装については、http：//www.programminglogic.com/fast-exponentiation-algorithms/を参照してください。ここでSwiftに変換しようとしました：

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
}

もちろん、これを呼び出すためにオーバーロードされた演算子を作成することでこれを空想でき、より汎用的になるように書き直して、IntegerTypeプロトコルを実装するあらゆるもので機能するようにすることができます。それを一般的にするために、私はおそらく次のようなものから始めるでしょう

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

しかし、それはおそらく夢中になっています。

あるいは単に ：

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

回答を多重定義された関数のセットに結合します（他の言語が使用する「^^」の代わりに「**」を使用します-私にはより明確です）：

// 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)) }

Floatを使用すると、精度が失われる場合があります。数値リテラルと、整数と非整数の混合を使用する場合、デフォルトではDoubleになります。私は個人的に、スタイル/読みやすさの理由から、pow（a、b）のような関数の代わりに数式を使用する機能が好きですが、それは私だけです。

pow（）にエラーをスローさせるすべての演算子は、これらの関数にもエラーをスローさせるため、エラーチェックの負担は、とにかくpower関数を使用するコードにあります。キス、私見。

ネイティブのpow（）関数を使用すると、たとえば平方根（2 ** 0.5）または逆数（2 ** -3 = 1/8）を取ることができます。逆指数または分数指数を使用する可能性があるため、すべてのコードを記述して、pow（）関数のデフォルトのDouble型を返します。必要に応じて、これはIntやFloatなどの型キャストにキャストできますが、精度が失われる可能性があります。

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

あなたも使えることがわかりましたpow()。たとえば、次のように使用すると、10から9を表現できます。

pow(10, 9)

返しの代わりに。私はこれをSwift 4とmacOS 10.13でのみテストしました。powpowf()floatdouble

を計算するにはpower(2, n)、次を使用します。

let result = 2 << (n-1)

Swift 4.xバージョン

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
}

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
    }
}

このように使う

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

@Paul Buisの回答に感謝します。

配列（繰り返し：a、カウント：b）.reduce（1、*）

Swift 5のベース2のビットシフトを介して値を直接計算するIntベースのpow関数：

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, *)
}

（結果がIntの範囲内であることを確認してください-これは範囲外のケースをチェックしません）

他の答えは素晴らしいですが、望ましい場合Intは、指数が正である限り、内線でそれを行うこともできます。

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

オーバーロードを組み合わせようとして、ジェネリックスを使用しようとしましたが、機能しませんでした。ようやく、ジェネリックをオーバーロードしたり使用したりする代わりに、NSNumberを使用することを考えました。これにより、次のことが簡単になります。

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

次のコードは上記と同じ関数ですが、エラーチェックを実装して、パラメーターをDoubleに正常に変換できるかどうかを確認しています。

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
    }
}

スウィフト5

驚いたが、ここでは適切な正しい解決策が見つからなかった。

これは私のものです：

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
    }
}

例：

CustomMath.pow(1,1)

私はこれが好きです

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

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

例：

calc (2,2)