¿Hay un operador exponente en C#?

Me tropecé en este post buscando usar notación científica en mi código, usé

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

Pero después descubrí que puedes hacer

4.95E-10;

Solo pensé que añadiría esto para cualquiera en una situación similar en la que yo estaba.

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

Sería posible añadir una potencia operador al idioma, pero la realización de esta operación es una cosa rara que hacer en la mayoría de los programas, y no parece justificado añadir un operador al llamar a Math.Pow () es simple.

Usted preguntó:

¿tengo que escribir un bucle o incluir otro espacio de nombres para manejar ¿operaciones exponenciales? En caso afirmativo, ¿cómo Manejo operaciones exponenciales usando no enteros?

Math.Pow admite parámetros dobles, por lo que no es necesario que escribas los tuyos propios.

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 desde el buen vb6.

Me alegro de haber ido con C# pero todavía me molesta cada vez que estoy escribiendo una ecuación compleja incluyendo exponentes. matemáticas.El método Pow () hace que las ecuaciones sean bastante difíciles de leer IMO.

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

Esto funciona bastante bien como 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 de nuevo 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 utilizan una gran cantidad de ecuaciones complejas en su código, y tal vez alguien incluso tiene 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 --------------
    }
}

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

float Result, Number1;

Result = Number1 * Number1;

Dado que nadie ha escrito todavía una función para hacer esto con dos 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

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