c# - una - pow en visual studio

¿Hay un operador 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 operador exponencial en otros lenguajes, pero en C # es un operador de bits.

¿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

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

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

Alternativamente 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 2

El lenguaje C # no tiene un operador de energía . Sin embargo, .NET Framework ofrece el método Math.Pow :

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

Entonces su ejemplo sería así:

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

Answer 3

Hay una publicación de blog en MSDN sobre por qué NO existe un operador exponente del equipo C #.

Sería posible agregar un operador de poder al idioma, pero realizar esta operación es bastante raro de hacer en la mayoría de los programas, y no parece justificado agregar un operador cuando se llama a Math.Pow () es simple.

Tu preguntaste:

¿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?

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

Answer 4

La falta de un operador exponencial para C # fue una gran molestia para nosotros cuando buscamos un nuevo lenguaje para convertir nuestro software de cálculo del buen viejo vb6.

Me alegro de haber ido con C #, pero todavía me molesta cada vez que escribo 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 DoubleX donde anulamos el operador ^ (ver a continuación)

Esto funciona bastante bien siempre que declare 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 use un convertidor explícito en dobles estándar:

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

Sin embargo, un problema con este método es que el exponente se calcula en el orden incorrecto en comparación con otros operadores. Esto se puede evitar poniendo siempre un extra () alrededor de la operación, lo que hace que sea un poco más difícil 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 pueda ser de ayuda para otros que usan muchas 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 --------------
}
}

Answer 5

Me encontré con esta publicación buscando usar la notación científica en mi código, utilicé

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

Pero después descubrí que puedes hacer

4.95E-10;

Solo pensé en agregar esto para cualquier persona en una situación similar en la que estuve.

Answer 6

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

float Result, Number1;
Result = Number1 * Number1;