¿Hay un operador de exponente en C#?

Question

Por ejemplo, ¿existe un operador para manejar esto?

float Result, Number1, Number2; 

Number1 = 2; 
Number2 = 2; 

Result = Number1 (operator) Number2; 

En el pasado el operador ^ ha servido como un operador exponencial en otros idiomas, pero en C# es un operador bit a bit.

¿Tengo que escribir un bucle o incluir otro espacio de nombres para manejar las operaciones exponenciales? Si es así, ¿cómo manejo las operaciones exponenciales usando números no enteros?

Answer 1

El lenguaje C# doesn't have a power operator. Sin embargo, .NET Framework ofrece el método Math.Pow:

Devuelve un número especificado elevado a la potencia especificada.

Así que su ejemplo podría tener este aspecto:

float Result, Number1, Number2; 

Number1 = 2; 
Number2 = 2; 

Result = Math.Pow(Number1, Number2); 

Answer 2

Hay una blog post on MSDN about why an exponent operator does NOT exists del equipo de C#.

Sería posible añadir un operario de la a la lengua, pero realizar esta operación es una cosa bastante rara que hacer en la mayoría de los programas, y no parece justificada para añadir un operador cuando llame al Math.Pow() es simple.

---

Se preguntó:

¿Tengo que escribir un bucle o incluir otro espacio de nombres para manejar operaciones exponenciales? Si es así, ¿cómo puedo manejar las operaciones exponenciales usando no enteros?

Math.Pow admite parámetros dobles, por lo que no es necesario que escriba uno propio.

Answer 3

me encontré con este post que buscan utilizar la notación científica en mi código, he utilizado

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

Pero después me enteré que puede hacer

4.95E-10; 

sólo pensé que añadiría a cualquiera en una situación similar a la que yo estaba.

Answer 4

Me sorprende que nadie haya mencionado esto, pero para el caso simple (y probablemente el más encontrado) de cuadratura, simplemente se multiplica por su duende.

float Result, Number1; 

Result = Number1 * Number1; 

Answer 5

Dado que aún nadie ha escrito una función para hacer esto con dos números enteros, aquí hay una manera:

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 

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

La falta de un operador exponencial para C# fue una gran molestia para nosotros en la búsqueda de un nuevo lenguaje para convertir nuestro software de cálculo a partir de los viejos VB6'.

Estoy contento de haber ido con C#, pero aún me molesta cada vez que estoy escribiendo una ecuación compleja que incluye exponentes. El método Math.Pow() hace que las ecuaciones sean bastante difíciles de leer como IMO.

Nuestra solución fue crear una clase especial donde DoubleX sobreescribimos el^-operator (ver más abajo)

Esto funciona bastante bien, siempre y cuando se declara al menos una de las variables como DoubleX:

DoubleX a = 2; 
DoubleX b = 3; 

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

o utilizar un convertidor explícita en dobles estándar:

double c = 2; 
double d = 3; 

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

un problema con este método es sin embargo que el exponente se calcula en el orden equivocado compa rojo a otros operadores. Esto se puede evitar poniendo siempre un extra() en torno a la operación que a su vez hace que sea un poco más difícil de leer las ecuaciones:

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 

espero que esto puede ser de ayuda para otras personas que utiliza una gran cantidad de ecuaciones complejas en su código, y tal vez alguien incluso tenga una idea de cómo mejorar este método ?! :-)

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