क्या सी # में एक एक्सपोनेंट ऑपरेटर है?

Question

उदाहरण के लिए, क्या ऑपरेटर इसे संभालने के लिए मौजूद है?

float Result, Number1, Number2; 

Number1 = 2; 
Number2 = 2; 

Result = Number1 (operator) Number2; 

अतीत ^ ऑपरेटर अन्य भाषाओं में एक घातीय ऑपरेटर के रूप में सेवा की है में, लेकिन सी # में यह थोड़ा-वार ऑपरेटर है।

क्या मुझे लूप लिखना है या घातीय परिचालनों को संभालने के लिए एक और नामस्थान शामिल करना है? यदि हां, तो मैं गैर-पूर्णांक का उपयोग करके घातीय संचालन कैसे संभालूं?

Answer 1

सी # भाषा doesn't have a power operator। हालांकि, .NET Framework Math.Pow विधि प्रदान करता है:

निर्दिष्ट शक्ति में निर्दिष्ट एक निर्दिष्ट संख्या देता है।

तो अपने उदाहरण इस प्रकार दिखाई देगा:

float Result, Number1, Number2; 

Number1 = 2; 
Number2 = 2; 

Result = Math.Pow(Number1, Number2); 

Answer 2

वहाँ सी # टीम से एक blog post on MSDN about why an exponent operator does NOT exists है।

यह भाषा के लिए एक शक्ति ऑपरेटर जोड़ने के लिए संभव हो जाएगा लेकिन प्रदर्शन कर इस आपरेशन ज्यादातर कार्यक्रमों में क्या करना एक काफी दुर्लभ बात है, और यह एक ऑपरेटर जोड़ने के लिए उचित प्रतीत नहीं होता Math.Pow() को कॉल करते समय सरल है।

---

आप से पूछा:

मैं एक पाश लिखने के लिए है या एक और नाम स्थान घातीय संचालन संभाल करने में शामिल है? यदि हां, तो कैसे मैं गैर-पूर्णांक का उपयोग करके घातीय संचालन को संभालता हूं?

Math.Pow डबल पैरामीटर का समर्थन करता है इसलिए आपको स्वयं लिखने की कोई आवश्यकता नहीं है।

Answer 3

मैं इस पोस्ट मेरी कोड में वैज्ञानिक संकेतन का उपयोग करने के लिए देख पर ठोकर खाई, मैं

4.95*Math.Pow(10,-10); 

इस्तेमाल किया लेकिन बाद में मुझे पता चला कि आप

कर सकते हैं

4.95E-10; 

बस मैं किसी के लिए भी यह जोड़ना होगा सोचा इसी तरह की स्थिति में मैं अंदर था।

Answer 4

मुझे आश्चर्य है कि किसी ने इसका उल्लेख नहीं किया है, लेकिन स्क्वायरिंग के सरल (और शायद सबसे अधिक सामना किए गए) मामले के लिए, आप बस इसके द्वारा गुणा करते हैं योगिनी।

float Result, Number1; 

Result = Number1 * Number1; 

Answer 5

के बाद से कोई दो पूर्णांकों के साथ ऐसा करने के लिए एक समारोह अभी तक लिखा गया है, यहाँ एक तरीका है:

private long CalculatePower(int Number, int PowerOf) { 
    long Result = Number;  
    for (int i = PowerOf; i > 1; i--) { 
     Result = (Result * Number); 
    } 
    return Result; 
} 
CalculatePower(5, 3); // 125 
CalculatePower(8, 4); // 4096 
CalculatePower(6, 2); // 36 

वैकल्पिक रूप से VB में

।नेट:

Private Function CalculatePower(Number As Integer, PowerOf As Integer) As Long 
    Dim Result As Long = Number 
    For i As Integer = PowerOf To 2 Step -1 
     Result = (Result * Number) 
    Next 
    Return Result 
End Function 
CalculatePower(5, 3) ' 125 
CalculatePower(8, 4) ' 4096 
CalculatePower(6, 2) ' 36 

Answer 6

सी # के लिए एक घातीय ऑपरेटर की कमी जब अच्छा ol से 'VB6 के लिए हमारी गणना सॉफ्टवेयर कन्वर्ट करने के लिए एक नई भाषा की तलाश में हमारे लिए एक बड़ी झुंझलाहट था।

मुझे खुशी है कि हम सी # के साथ गए थे, लेकिन जब भी मैं एक्सपोनेंट समेत जटिल समीकरण लिख रहा हूं तब भी मुझे परेशान करता है। Math.Pow() विधि आईएमओ पढ़ने के लिए समीकरणों को काफी कठिन बनाता है।

DoubleX a = 2; 
DoubleX b = 3; 

Console.WriteLine($"a = {a}, b = {b}, a^b = {a^b}"); 

:

हमारा समाधान जहां हम^-operator ओवरराइड एक विशेष DOUBLEX वर्ग बनाने के लिए (नीचे देखें)

यह जब तक आप DOUBLEX के रूप में चर के कम से कम एक की घोषणा काफी अच्छी तरह से काम करता है था

या मानक युगल पर एक स्पष्ट कनवर्टर का उपयोग: इस विधि यह है कि है प्रतिपादक गलत क्रम कंपनियों में गणना की जाती है साथ

double c = 2; 
double d = 3; 

Console.WriteLine($"c = {c}, d = {d}, c^d = {c^(DoubleX)d}");  // Need explicit converter 

एक समस्या यह है अन्य ऑपरेटरों के लिए लाल।

DoubleX a = 2; 
DoubleX b = 3; 

Console.WriteLine($"a = {a}, b = {b}, 3+a^b = {3 + a^b}");  // Wrong result 
Console.WriteLine($"a = {a}, b = {b}, 3+a^b = {3 + (a^b)}");  // Correct result 

मुझे आशा है कि यह जो जटिल समीकरणों का एक बहुत का उपयोग करता है दूसरों के लिए सहायक हो सकता है: यह हमेशा आपरेशन जो फिर से यह थोड़ा कठिन समीकरणों पढ़ा जा सकता है चारों ओर एक अतिरिक्त() डालने से बचा जा सकता उनके कोड, और शायद किसी को भी इस विधि को सुधारने का विचार है ?! :-)

DOUBLEX वर्ग:

using System; 

namespace ExponentialOperator 
{ 
    /// <summary> 
    /// Double class that uses^as exponential operator 
    /// </summary> 
    public class DoubleX 
    { 
     #region ---------------- Fields ---------------- 

     private readonly double _value; 

     #endregion ------------- Fields ---------------- 

     #region -------------- Properties -------------- 

     public double Value 
     { 
      get { return _value; } 
     } 

     #endregion ----------- Properties -------------- 

     #region ------------- Constructors ------------- 

     public DoubleX(double value) 
     { 
      _value = value; 
     } 

     public DoubleX(int value) 
     { 
      _value = Convert.ToDouble(value); 
     } 

     #endregion ---------- Constructors ------------- 

     #region --------------- Methods ---------------- 

     public override string ToString() 
     { 
      return _value.ToString(); 
     } 

     #endregion ------------ Methods ---------------- 

     #region -------------- Operators --------------- 

     // Change the^operator to be used for exponents. 

     public static DoubleX operator ^(DoubleX value, DoubleX exponent) 
     { 
      return Math.Pow(value, exponent); 
     } 

     public static DoubleX operator ^(DoubleX value, double exponent) 
     { 
      return Math.Pow(value, exponent); 
     } 

     public static DoubleX operator ^(double value, DoubleX exponent) 
     { 
      return Math.Pow(value, exponent); 
     } 

     public static DoubleX operator ^(DoubleX value, int exponent) 
     { 
      return Math.Pow(value, exponent); 
     } 

     #endregion ----------- Operators --------------- 

     #region -------------- Converters -------------- 

     // Allow implicit convertion 

     public static implicit operator DoubleX(double value) 
     { 
      return new DoubleX(value); 
     } 

     public static implicit operator DoubleX(int value) 
     { 
      return new DoubleX(value); 
     } 

     public static implicit operator Double(DoubleX value) 
     { 
      return value._value; 
     } 

     #endregion ----------- Converters -------------- 
    } 
}