Gibt es in C# einen Exponentenoperator?

Question

Gibt es zum Beispiel einen Operator, der damit umgehen kann?

float Result, Number1, Number2; 

Number1 = 2; 
Number2 = 2; 

Result = Number1 (operator) Number2; 

In der Vergangenheit ist der ^ Operator als ein exponentiellen Operator in anderen Sprachen, aber in C# gedient hat, ist es ein bitweise Operator.

Muss ich eine Schleife schreiben oder einen anderen Namespace für exponentielle Operationen einbeziehen? Wenn ja, wie handhabe ich exponentielle Operationen mit Nicht-Ganzzahlen?

Answer 1

Die C# -Sprache doesn't have a power operator. Das .NET Framework bietet jedoch die Methode Math.Pow an:

Gibt eine angegebene Zahl mit der angegebenen Leistung zurück.

So würde Ihr Beispiel wie folgt aussehen:

float Result, Number1, Number2; 

Number1 = 2; 
Number2 = 2; 

Result = Math.Pow(Number1, Number2); 

Answer 2

Es gibt eine blog post on MSDN about why an exponent operator does NOT exists aus dem C# Team ist.

Es wäre möglich, eine Leistung Operator der Sprache hinzuzufügen, aber Durchführung dieser Operation eine ziemlich seltene Sache ist in den meisten Programmen zu tun, und es nicht gerechtfertigt scheinen eine Betreiber hinzufügen beim Aufruf Math.Pow() ist einfach.

---

Sie gefragt:

Muss ich eine Schleife zu schreiben oder zu schließen ein anderer Namespace exponentielle Operationen zu behandeln? Wenn ja, wie funktioniert ich exponentiellen Operationen mit nicht-Ganzzahlen?

Math.Pow unterstützt doppelte Parameter, so dass Sie keine eigenen schreiben müssen.

Answer 3

ich auf diesen Beitrag gestolpert suchen in meinem Code wissenschaftliche Schreibweise zu benutzen, ich

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

verwendet Aber danach fand ich heraus, Sie

4.95E-10; 

Gerade dachte ich, das für jedermann möchte hinzufügen, tun können in einer ähnlichen Situation, in der ich war.

Answer 4

Ich bin überrascht, dass niemand dies erwähnt hat, aber für den einfachen (und wahrscheinlich am meisten angetroffenen) Fall des Quadrierens multiplizieren Sie einfach durch sein Elf.

float Result, Number1; 

Result = Number1 * Number1; 

Answer 5

Da niemand hat noch eine Funktion, dies zu tun mit zwei ganzen Zahlen schrieb, hier ist ein Weg:

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 

Alternativ in VB.NET:

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

Das Fehlen eines exponentiellen Operator für C# war ein großes Ärgernis für uns, wenn für eine neue Sprache sucht unsere Berechnungssoftware aus dem guten alten VB6 zu konvertieren.

Ich bin froh, dass wir mit C# gegangen sind, aber es ärgert mich immer, wenn ich eine komplexe Gleichung einschließlich Exponenten schreibe. Die Math.Pow() - Methode macht Gleichungen sehr schwer zu lesen IMO.

war unsere Lösung eine spezielle DoubleX Klasse zu schaffen, in dem wir die^-Operator (siehe unten) außer Kraft setzen

Diese ziemlich gut, so lange funktioniert, wie Sie mindestens eine der Variablen als DoubleX erklären:

DoubleX a = 2; 
DoubleX b = 3; 

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

oder einen expliziten Konverter auf Standard-Doppelzimmer verwenden:

double c = 2; 
double d = 3; 

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

ein Problem bei dieser Methode ist jedoch, dass der Exponent in der falschen Reihenfolge compa berechnet rot zu anderen Betreibern. Dies kann durch immer setzen eine zusätzliche() um den Betrieb vermieden werden, was wiederum macht es etwas schwieriger, die Gleichungen zu lesen:

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 

Ich hoffe, dass diese Hilfe für andere sein können, die viel komplexer Gleichungen verwendet in ihr Code, und vielleicht hat jemand sogar eine Idee, wie man diese Methode verbessern kann ?! :-)

DoubleX Klasse:

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