Как получить Power of Some Integer на языке Swift?

Я недавно учусь быстро, но у меня есть основная проблема, на которую я не могу найти ответ

Я хочу получить что-то вроде

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

но функция pow может работать только с двойным числом, она не работает с целым числом, и я даже не могу привести int к удвоению чем-то вроде Double (a) или a.double () ...

Почему он не обеспечивает степень целого числа? он обязательно вернет целое число без двусмысленности! и почему я не могу преобразовать целое число в двойное? просто измените 3 на 3,0 (или 3,00000 ... что угодно)

если у меня есть два целых числа, и я хочу выполнить операцию питания, как я могу сделать это плавно?

Спасибо!

Если хотите, вы можете объявить, 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 .

Обновление для 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 Ints и хотите вернуть 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 прав в отношении возведения в степень возведения в квадрат как стандартного алгоритма для вычисления целочисленных степеней, но хвостовая рекурсивная реализация алгоритма кажется немного запутанной. См. Http://www.programminglogic.com/fast-exponentiation-algorithms/ для нерекурсивной реализации возведения в степень возведением в квадрат в C. Я попытался перевести это на 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 (), также будут вызывать ошибку этими функциями, поэтому бремя проверки ошибок все равно лежит на коде, использующем функцию мощности. KISS, ИМХО.

Использование встроенной функции pow () позволяет, например, извлекать квадратные корни (2 ** 0,5) или обратные (2 ** -3 = 1/8). Из-за возможности использования обратных или дробных показателей я написал весь свой код так, чтобы он возвращал тип Double по умолчанию функции pow (), который должен возвращать наибольшую точность (если я правильно помню документацию). При необходимости это может быть преобразовано в тип Int или Float или что-то еще, возможно, с потерей точности.

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

Оказывается, можно и использовать pow(). Например, вы можете использовать следующее, чтобы выразить 10 до 9-го.

pow(10, 9)

Наряду с pow, powf()возвращает floatвместо double. Я тестировал это только на Swift 4 и macOS 10.13.

Для расчета 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, count: b) .reduce (1, *)

Функция pow на основе Int, которая вычисляет значение напрямую через битовый сдвиг для базы 2 в 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, *)
}

(Убедитесь, что результат находится в диапазоне 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))}

Следующий код представляет собой ту же функцию, что и выше, но реализует проверку ошибок, чтобы увидеть, можно ли успешно преобразовать параметры в двойные.

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

Swift 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)