web-dev-qa-db-fra.com

Opérateur d’exponentiation dans Swift

Je ne vois pas d'opérateur d'exponentiation défini dans les opérateurs arithmétiques de base dans la référence du langage Swift. 

N'existe-t-il vraiment aucun opérateur prédéfini de type entier ou exponentionneur flottant dans le langage?

swiftexponentiation
59
mcgregor94086

Il n'y a pas d'opérateur mais vous pouvez utiliser la fonction pow comme ceci:

return pow(num, power)

Si vous le souhaitez, vous pouvez également demander à un opérateur d'appeler la fonction pow de la manière suivante:

infix operator ** { associativity left precedence 170 }

func ** (num: Double, power: Double) -> Double{
    return pow(num, power)
}

2.0**2.0 //4.0
75
Connor

Si vous élevez 2 à une certaine puissance, vous pouvez utiliser l'opérateur de décalage gauche au niveau du bit:

let x = 2 << 0    // 2
let y = 2 << 1    // 4
let z = 2 << 7    // 256

Notez que la valeur de "puissance" est 1 inférieure à ce que vous pourriez penser.

Notez que ceci est plus rapide que pow(2.0, 8.0) et vous évite d’avoir à utiliser des doublons.

21
chanceoperation

Pour ceux qui recherchent une version Swift 3 de l'opérateur ** infix:

precedencegroup ExponentiationPrecedence {
  associativity: right
  higherThan: MultiplicationPrecedence
}

infix operator ** : ExponentiationPrecedence

func ** (_ base: Double, _ exp: Double) -> Double {
  return pow(base, exp)
}

func ** (_ base: Float, _ exp: Float) -> Float {
  return pow(base, exp)
}

2.0 ** 3.0 ** 2.0    // 512
(2.0 ** 3.0) ** 2.0  // 64
12
reitermarkus

Je l'ai fait comme ça:

operator infix ** { associativity left precedence 200 }

func ** (base: Double, power: Double) -> Double {
    return exp(log(base) * power)
}
5
ldanilek

Il n'y en a pas, mais vous avez la fonction pow.

3
Rod

Comme la plupart des langues de la famille C, il n'y en a pas.

1
David Berry

Si vous êtes particulièrement intéressé par l'opérateur d'exponentiation pour le type Int, je ne pense pas que les réponses existantes fonctionneraient particulièrement bien pour les grands nombres en raison de la façon dont les nombres en virgule flottante sont représentés en mémoire. Lors de la conversion en Float ou Double à partir de Int puis en retour (requis par les fonctions pow, powf et powl dans le module Darwin) vous risquez de perdre la précision . Voici une version précise pour Int:

let pow = { Array(repeating: $0, count: $1).reduce(1, *) }

Notez que cette version n’est pas particulièrement efficace en mémoire et est optimisée pour la taille du code source. 

Une autre version qui ne créera pas de tableau intermédiaire:

func pow(_ x: Int, _ y: Int) -> Int {
  var result = 1
  for i in 0..<y {
    result *= x
  }
  return result
}
1
Max Desiatov

Swift 4.2

var n = 1.0
var result = 45 * pow(n, 3) + 20 * pow(n, 2) + 19
print(result)
// 84.0
0
tymac

Une autre solution consiste à utiliser NSExpression.

let mathExpression = NSExpression(format:"2.5**2.5")
let answer = mathExpression.expressionValue(with: nil, context: nil) as? Double

ou

let mathExpression = NSExpression(format:"2**3")
let answer = mathExpression.expressionValue(with: nil, context: nil) as? Int
0
Ryan Heitner