Esiste un operatore esponente in C #?

Ad esempio, esiste un operatore per gestirlo?

float Result, Number1, Number2; Number1 = 2; Number2 = 2; Result = Number1 (operator) Number2; 

In passato l’operatore ^ è servito come operatore esponenziale in altre lingue, ma in C # è un operatore bit-saggio.

Devo scrivere un ciclo o includere un altro spazio dei nomi per gestire le operazioni esponenziali? In caso affermativo, come gestisco le operazioni esponenziali usando non-interi?

Il linguaggio C # non ha un operatore di alimentazione . Tuttavia, .NET Framework offre il metodo Math.Pow :

Restituisce un numero specificato elevato alla potenza specificata.

Quindi il tuo esempio dovrebbe assomigliare a questo:

 float Result, Number1, Number2; Number1 = 2; Number2 = 2; Result = Math.Pow(Number1, Number2); 

Mi sono imbattuto in questo post cercando di usare la notazione scientifica nel mio codice, ho usato

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

Ma dopo ho scoperto che puoi farlo

 4.95E-10; 

Ho pensato di aggiungere questo a chiunque si trovasse in una situazione simile in cui mi trovavo.

C’è un post sul blog su MSDN sul motivo per cui un operatore esponente NON esiste dal team C #.

Sarebbe ansible aggiungere un operatore di potenza alla lingua, ma eseguire questa operazione è una cosa abbastanza rara da fare nella maggior parte dei programmi, e non sembra giustificato aggiungere un operatore quando si chiama Math.Pow () è semplice.


Hai chiesto:

Devo scrivere un ciclo o includere un altro spazio dei nomi per gestire le operazioni esponenziali? In caso affermativo, come gestisco le operazioni esponenziali usando non-interi?

Math.Pow supporta i doppi parametri quindi non è necessario che tu scriva il tuo.

La mancanza di un operatore esponenziale per C # è stata una grande seccatura per noi quando cercavamo una nuova lingua per convertire il nostro software di calcolo dal buon vecchio vb6.

Sono contento che siamo andati con C # ma mi infastidisce ancora ogni volta che scrivo un’equazione complessa che include esponenti. Il metodo Math.Pow () rende le equazioni abbastanza difficili da leggere IMO.

La nostra soluzione era di creare una speciale class DoubleX in cui sostituiamo il ^ -operator (vedi sotto)

Funziona abbastanza bene se dichiari almeno una delle variabili come DoubleX:

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

o utilizzare un convertitore esplicito su doppi standard:

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

Un problema con questo metodo è che l’esponente viene calcolato nell’ordine sbagliato rispetto ad altri operatori. Questo può essere evitato mettendo sempre un extra () attorno all’operazione che rende di nuovo più difficile leggere le equazioni:

 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 

Spero che questo possa essere di aiuto ad altri che usano molte equazioni complesse nel loro codice, e forse qualcuno ha persino un’idea di come migliorare questo metodo ?! 🙂

Classe DoubleX:

 using System; namespace ExponentialOperator { ///  /// Double class that uses ^ as exponential operator ///  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 -------------- } } 

Sono sorpreso che nessuno abbia menzionato questo, ma per il semplice (e probabilmente il più incontrato) caso di quadratura, si moltiplica da solo.

 float Result, Number1; Result = Number1 * Number1; 

Dal momento che nessuno ha ancora scritto una funzione per farlo con due numeri interi, ecco un modo:

 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 

In alternativa 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