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 --------------
}
}
**als Infix-Exponentiationsoperator verwendet.