L'absence d'un opérateur exponentiel pour C # était une grande gêne pour nous lorsque nous recherchions un nouveau langage pour convertir notre logiciel de calcul à partir du bon vieux vb6.
Je suis content que nous ayons choisi C # mais cela m'ennuie toujours quand j'écris une équation complexe incluant des exposants. La méthode Math.Pow () rend les équations assez difficiles à lire IMO.
Notre solution a été de créer une classe DoubleX spéciale où nous remplaçons l'opérateur ^ (voir ci-dessous)
Cela fonctionne assez bien tant que vous déclarez au moins une des variables comme DoubleX:
DoubleX a = 2;
DoubleX b = 3;
Console.WriteLine($"a = {a}, b = {b}, a^b = {a ^ b}");
ou utilisez un convertisseur explicite sur les doubles standard:
double c = 2;
double d = 3;
Console.WriteLine($"c = {c}, d = {d}, c^d = {c ^ (DoubleX)d}"); // Need explicit converter
Un problème avec cette méthode est cependant que l'exposant est calculé dans le mauvais ordre par rapport aux autres opérateurs. Cela peut être évité en mettant toujours un extra () autour de l'opération, ce qui rend encore plus difficile la lecture des équations:
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
J'espère que cela peut être utile à d'autres qui utilisent beaucoup d'équations complexes dans leur code, et peut-être que quelqu'un a même une idée de la façon d'améliorer cette méthode?! :-)
Classe 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 --------------
}
}
**comme opérateur d'exponentiation d'infixe.