¿Hay un operador exponente en C #?

Question

Por ejemplo, existen hace 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 se gestionan las operaciones exponenciales usando no enteros?

Answer 1

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

  

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

Así que su ejemplo se vería así:

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Math.Pow(Number1, Number2);

Answer 2

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

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

Pero después descubrí que puede hacer

4.95E-10;

Sólo pensaba que iba a añadir este para cualquier persona en una situación similar que la que estaba.

Answer 3

Hay una entrada de blog en MSDN acerca de por qué una operador exponente nO existe del equipo de C #.

  

Sería posible añadir un poder   operador de la lengua, pero   realizar esta operación es bastante   cosa rara que hacer en la mayoría de los programas, y   no parece justificado para añadir una   operador al llamar Math.pow () es   sencilla.

---

Se preguntó:

  

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

Math.pow admite parámetros dobles así que no hay necesidad para que usted escriba su propio.

Answer 4

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 buenos viejos VB6.

Me alegro de haber ido con C #, pero todavía me molesta cuando estoy escribiendo una ecuación compleja que incluye exponentes. El método Math.pow () hace que las ecuaciones bastante duros leer la OMI.

Nuestra solución fue crear una clase especial DoubleX donde sobreescribimos el ^ -operator (véase más adelante)

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 respecto a otros operadores. Esto puede ser evitado por siempre poniendo 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 incluso alguien 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 --------------
    }
}

Answer 5

Me sorprende que nadie ha mencionado esto, pero por el simple (y probablemente la mayoría encontró) caso de la cuadratura, que acaba de multiplicar por sí mismo.

float Result, Number1;

Result = Number1 * Number1;

Answer 6

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)
{
    for (int i = powerOf; i > 1; i--)
        number *= number;
    return number;
}
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
    For i As Integer = powerOf To 2 Step -1
        number *= number
    Next
    Return number
End Function
CalculatePower(5, 3) ' 125
CalculatePower(8, 4) ' 4096
CalculatePower(6, 2) ' 36

Answer 7

Una buena función de potencia sería

    public long Power(int number, int power) {
        if (number == 0) return 0;
        long t = number;
        int e = power;
        int result = 1;
        for(i=0; i<sizeof(int); i++) {
            if (e & 1 == 1) result *= t;
            e >>= 1;
            if (e==0) break;
            t = t * t;
        }
    }

La función `Math.Pow` utiliza la función de la potencia del procesador y es altamente eficiente.