स्विफ्ट में एक्सपेंशनशिप ऑपरेटर

Question

मुझे स्विफ्ट भाषा के संदर्भ में आधार अंकगणितीय ऑपरेटरों में परिभाषित प्रतिपादक ऑपरेटर नहीं दिखता है।

क्या वास्तव में भाषा में कोई पूर्वनिर्धारित पूर्णांक या फ्लोट प्रतिपादक ऑपरेटर नहीं है?

Comments

मेरे मामले में, इस समाधान के रूप में काम किया: stackoverflow.com/a/28710112/2161007

— नैय्यर

Answer 1

कोई ऑपरेटर नहीं है, लेकिन आप इस तरह पॉव फ़ंक्शन का उपयोग कर सकते हैं:

return pow(num, power)

यदि आप चाहते हैं, तो आप एक ऑपरेटर को इस तरह से पॉव फ़ंक्शन कॉल कर सकते हैं:

infix operator ** { associativity left precedence 170 }

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

2.0**2.0 //4.0

Comments

उपयोग करने के लिए बेहतर है **, इसलिए आप इसे स्याही पर उपयोग कर सकते हैं और XOR के साथ संघर्ष नहीं कर सकते।

— केविन

^ स्विफ्ट में ऑपरेटर को XOR के रूप में परिभाषित किया गया है।

— कोस्टिएन्टिन कोवल

चेतावनी! यहां एक समस्या है। उदाहरण के लिए, आम तौर पर में, भाषाओं प्रोग्रामिंग -2.0**2.0 = -(2.0**2.0) = -4.0। हालांकि, यहां -2.0**2.0 = (-2.0)**2.0 = 4.0, जो कि इच्छित उपयोग नहीं हो सकता है और बग को ट्रैक करने के लिए काफी बुरा और कठिन हो सकता है।

— डैनियल फैरेल

NSHipster एक समान विवरण का उपयोग करता है लेकिन मिलान करने के लिए <<और 160 की पूर्वता के साथ >>। अलग-अलग प्राथमिकताओं से अलग-अलग कोड व्याख्याएं होंगी, इसलिए आम ऑपरेटरों के लिए एक पूर्वता पर मानकीकरण महत्वपूर्ण है। मुझे नहीं पता कि सबसे अच्छा मानक क्या है, लेकिन देना << 2और ** 2उसी तरह की मिसाल कुछ मायने रखती है। nshipster.com/swift-operators

— ओमेगामन

क्या घातांक सही सहयोगी नहीं है? en.wikipedia.org/wiki/Operator_associativity

— vwvan

Answer 2

यदि आप किसी शक्ति के लिए 2 बढ़ा रहे हैं, तो आप बिटवाइड लेफ्ट शिफ्ट ऑपरेटर का उपयोग कर सकते हैं:

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

ध्यान दें कि 'शक्ति' का मूल्य आपके विचार से 1 कम है।

ध्यान दें कि यह तेजी से है pow(2.0, 8.0)और इससे आप डबल्स का उपयोग करने से बच सकते हैं।

Comments

यह अच्छा है जहाँ तक यह जाता है, लेकिन वास्तव में इस सवाल का जवाब नहीं है।

— क्रिस

मुझे दो की शक्तियों में दिलचस्पी थी, इसलिए इसने मेरे लिए इसका जवाब दिया।

— dldnh

@chanceoperation वैकल्पिक रूप से, n की शक्ति के लिए 2 के लिए आप n स्थानों पर 1 या 0b00000001 को बाईं ओर शिफ्ट कर सकते हैं उन्नत ऑपरेटरों let x = 0b00000001 << exponent // 2**exponent let x = 1 << 0 // 1 let x = 1 << 2 // 4 let x = 1 << 8 // 256

— beepscore

Answer 3

**इन्फिक्स ऑपरेटर के एक स्विफ्ट 3 संस्करण की तलाश में किसी के लिए :

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

Comments

अच्छा लगा। import Darwinपाने के लिए मत भूलनाpow

— iainH

बहुत यकीन है कि संबद्धता को छोड़ दिया जाना चाहिए, न कि सही। 2 ^ 3 ^ 2 64 है, 512 नहीं।

— ब्रांडनस्क्रिप्ट

खैर, पायथन और जावास्क्रिप्ट दोनों 2**3**2में ५१२ है, ६४ नहीं। मैं किसी भी प्रोग्रामिंग भाषा को बाएं-सहयोगी एक्सपोनेंट्री ऑपरेटर के साथ नहीं जानता। वे सभी सही सहयोगी हैं। यदि आप इसे स्विफ्ट में लागू करते हैं, तो आपको निश्चित रूप से अन्य लोकप्रिय भाषाओं के साथ-साथ गणितीय सम्मेलन के अनुरूप होने के लिए यह सही-सहयोगी होना चाहिए ।

— रे तोल

Answer 4

मैंने इसे पसंद किया:

operator infix ** { associativity left precedence 200 }

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

Comments

ऐसा लगता है ... अक्षम

— sam-w

Answer 5

स्विफ्ट 4.2

import Foundation

var n = 2.0 // decimal
var result = 5 * pow(n, 2)
print(result)
// 20.0

Answer 6

वहाँ एक नहीं है, लेकिन आपके पास powफ़ंक्शन है।

Answer 7

यदि आप विशेष रूप से Intप्रकार के लिए घातांक ऑपरेटर में रुचि रखते हैं , तो मुझे नहीं लगता कि मौजूदा उत्तर विशेष रूप से बड़ी संख्या के लिए अच्छी तरह से काम करेंगे जिस तरह से फ़्लोटिंग पॉइंट संख्याओं को स्मृति में दर्शाया जाता है। जब में कनवर्ट करने Floatया Doubleसे Intवापस और फिर (के लिए आवश्यक है जो pow, powfऔर powlकार्यों में Darwinमॉड्यूल) आप परिशुद्धता खो सकते हैं । इसके लिए एक सटीक संस्करण यहां दिया गया है Int:

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

ध्यान दें कि यह संस्करण विशेष रूप से मेमोरी कुशल नहीं है और स्रोत कोड आकार के लिए अनुकूलित है।

एक और संस्करण जो एक मध्यवर्ती सरणी नहीं बनाएगा:

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

Answer 8

अधिकांश सी-परिवार भाषाओं की तरह, एक नहीं है।

Answer 9

NSExpression का उपयोग करने के लिए एक वैकल्पिक उत्तर है

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

या

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