Gibt es einen Exponentenoperator in C #?

Gibt es beispielsweise einen Operator, der dies handhabt?

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Number1 (operator) Number2;

In der Vergangenheit ^hat der Operator in anderen Sprachen als Exponentialoperator gedient, in C # ist er jedoch ein bitweiser Operator.

Muss ich eine Schleife schreiben oder einen anderen Namespace einfügen, um exponentielle Operationen zu verarbeiten? Wenn ja, wie gehe ich mit Exponentialoperationen mit Nicht-Ganzzahlen um?

Die C # -Sprache hat keinen Energieoperator . Das .NET Framework bietet jedoch die Math.Pow- Methode:

Gibt eine angegebene Zahl zurück, die auf die angegebene Potenz angehoben wurde.

Ihr Beispiel würde also so aussehen:

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Math.Pow(Number1, Number2);

Ich bin über diesen Beitrag gestolpert, um die wissenschaftliche Notation in meinem Code zu verwenden, den ich verwendet habe

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

Aber danach habe ich herausgefunden, dass du es kannst

4.95E-10;

Ich dachte nur, ich würde dies für jeden in einer ähnlichen Situation hinzufügen, in der ich mich befand.

Auf MSDN gibt es einen Blog-Beitrag darüber, warum es im C # -Team KEINEN Exponentenoperator gibt .

Es wäre möglich, der Sprache einen Operator hinzuzufügen, aber diese Operation ist in den meisten Programmen ziemlich selten und es scheint nicht gerechtfertigt, einen Operator hinzuzufügen, wenn Math.Pow () aufgerufen wird.

Du hast gefragt:

Muss ich eine Schleife schreiben oder einen anderen Namespace einfügen, um exponentielle Operationen zu verarbeiten? Wenn ja, wie gehe ich mit Exponentialoperationen mit Nicht-Ganzzahlen um?

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

Das Fehlen eines Exponentialoperators für C # war für uns ein großes Ärgernis, als wir nach einer neuen Sprache suchten, in die wir unsere Berechnungssoftware vom guten alten vb6 konvertieren konnten.

Ich bin froh, dass wir uns für C # entschieden haben, aber es nervt mich immer noch, wenn ich eine komplexe Gleichung mit Exponenten schreibe. Die Math.Pow () -Methode macht es ziemlich schwierig, Gleichungen IMO zu lesen.

Unsere Lösung bestand darin, eine spezielle DoubleX-Klasse zu erstellen, in der wir den ^ -Operator überschreiben (siehe unten).

Dies funktioniert ziemlich gut, solange Sie mindestens eine der Variablen als DoubleX deklarieren:

DoubleX a = 2;
DoubleX b = 3;

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

oder verwenden Sie einen expliziten Konverter für Standard-Doubles:

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 im Vergleich zu anderen Operatoren in der falschen Reihenfolge berechnet wird. Dies kann vermieden werden, indem immer ein zusätzliches () um die Operation gesetzt wird, was das Lesen der Gleichungen wiederum etwas erschwert:

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 dies anderen helfen kann, die viele komplexe Gleichungen in ihrem Code verwenden, und vielleicht hat sogar jemand eine Idee, wie diese Methode verbessert werden 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 --------------
    }
}

Ich bin überrascht, dass dies niemand erwähnt hat, aber für den einfachen (und wahrscheinlich am häufigsten anzutreffenden) Fall des Quadrierens multiplizieren Sie einfach mit sich selbst.

float Result, Number1;

Result = Number1 * Number1;

Da noch niemand eine Funktion geschrieben hat, um dies mit zwei ganzen Zahlen zu tun, gibt es eine Möglichkeit:

private long CalculatePower(int number, int powerOf)
{
    for (int i = powerOf; i > 1; i--)
        number *= number;
    return number;
}
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
    For i As Integer = powerOf To 2 Step -1
        number *= number
    Next
    Return number
End Function
CalculatePower(5, 3) ' 125
CalculatePower(8, 4) ' 4096
CalculatePower(6, 2) ' 36

Eine gute Powerfunktion wäre

    public long Power(int number, int power) {
        if (number == 0) return 0;
        long t = number;
        int e = power;
        int result = 1;
        for(i=0; i<sizeof(int); i++) {
            if (e & 1 == 1) result *= t;
            e >>= 1;
            if (e==0) break;
            t = t * t;
        }
    }

Die Funktion "Math.Pow" verwendet die Prozessorleistungsfunktion und ist sehr effizient.

Für das, was es wert ist, vermisse ich den Operator ^, wenn ich eine Potenz von 2 erhöhe, um eine binäre Konstante zu definieren. Math.Pow () kann dort nicht verwendet werden, aber das Verschieben eines vorzeichenlosen int von 1 um den Wert des Exponenten nach links funktioniert. Als ich eine Konstante von (2 ^ 24) -1 definieren musste:

public static int Phase_count = 24;
public static uint PatternDecimal_Max = ((uint)1 << Phase_count) - 1;

Denken Sie daran, dass die Typen (uint) << (int) sein müssen.