web-dev-qa-db-fra.com

Y a-t-il un opérateur d'exposant en C #?

Par exemple, un opérateur existe-t-il pour gérer cela?

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Number1 (operator) Number2;

Dans le passé, l'opérateur ^ a servi d'opérateur exponentiel dans d'autres langues, mais en C #, il s'agit d'un opérateur binaire.

Dois-je écrire une boucle ou inclure un autre espace de noms pour gérer des opérations exponentielles? Si tel est le cas, comment gérer les opérations exponentielles avec des nombres non entiers?

c#operatorsexponent
170
Charlie

Le langage C # n'a pas d'opérateur électrique . Cependant, le .NET Framework offre la méthode Math.Pow :

Renvoie un nombre spécifié élevé à la puissance spécifiée.

Donc, votre exemple ressemblerait à ceci:

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Math.Pow(Number1, Number2);
202
dtb

Je suis tombé sur ce post en cherchant à utiliser la notation scientifique dans mon code, j'ai utilisé

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

Mais après j'ai découvert que vous pouvez faire

4.95E-10;

Je pensais juste que j'ajouterais ceci à quiconque se trouverait dans une situation similaire à celle dans laquelle j'étais.

42
General Grey

Il y a un article de blog sur MSDN expliquant pourquoi un opérateur d'exposant n'existe PAS de l'équipe C #.

Il serait possible d’ajouter un opérateur électrique au langage, mais cette opération est une opération assez rare dans la plupart des programmes, et il ne semble pas justifié d’ajouter un opérateur lorsqu’on appelle Math.Pow = () est simple.

Tu as demandé:

Dois-je écrire une boucle ou inclure un autre espace de noms pour gérer des opérations exponentielles? Si tel est le cas, comment gérer les opérations exponentielles avec des nombres non entiers?

Math.Pow prend en charge les paramètres doubles, vous n'avez donc pas besoin d'écrire vos propres paramètres.

31
Brian R. Bondy

L'absence d'un opérateur exponentiel pour C # était un gros désagrément lorsque nous recherchions un nouveau langage pour convertir notre logiciel de calcul du bon vieux logiciel 'vb6.

Je suis content que nous ayons opté pour C #, mais cela me dérange toujours lorsque j'écris une équation complexe incluant des exposants. La méthode Math.Pow () rend les équations assez difficiles à lire pour OMI.

Notre solution consistait à créer une classe DoubleX spéciale dans laquelle nous substituons l'opérateur ^ (voir ci-dessous).

Cela fonctionne assez bien tant que vous déclarez au moins une des variables en tant que DoubleX:

DoubleX a = 2;
DoubleX b = 3;

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

ou utilisez un convertisseur explicite sur les doubles standard:

double c = 2;
double d = 3;

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

Un problème avec cette méthode est que l’exposant est calculé dans le mauvais ordre par rapport aux autres opérateurs. Cela peut être évité en mettant toujours un extra () autour de l'opération, ce qui rend encore un peu plus difficile la lecture des équations:

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

J'espère que cela pourra aider d'autres utilisateurs qui utilisent beaucoup d'équations complexes dans leur code, et peut-être que quelqu'un a même une idée de la façon d'améliorer cette méthode?! :-)

Classe 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 --------------
    }
}
5
Petter

Je suis surpris que personne ne l'ait mentionné, mais pour le cas simple (et probablement le plus souvent rencontré) de quadrature, vous ne faites que multiplier par lui-même.

float Result, Number1;

Result = Number1 * Number1;
2
RubberDuck

Comme personne n'a encore écrit de fonction pour le faire avec deux entiers, voici un moyen:

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

Alternativement dans 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
1
Nathangrad