Есть ли оператор степени в C #? - PullRequest
166 голосов
/ 14 июня 2010

Например, существует ли оператор для обработки этого?

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Number1 (operator) Number2;

В прошлом оператор ^ служил экспоненциальным оператором в других языках, но в C # это побитовый оператор.

Нужно ли писать цикл или включать другое пространство имен для обработки экспоненциальных операций? Если да, то как мне обрабатывать экспоненциальные операции, используя нецелые числа?

Ответы [ 6 ]

198 голосов
/ 14 июня 2010

Язык C # не имеет оператора . Однако .NET Framework предлагает метод Math.Pow :

Возвращает указанное число, возведенное в указанную степень.

Итак, ваш пример будет выглядеть так:

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Math.Pow(Number1, Number2);
42 голосов
/ 11 января 2014

Я наткнулся на этот пост, пытаясь использовать научную нотацию в моем коде, я использовал

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

Но потом я узнал, что ты можешь сделать

4.95E-10;

Просто подумал, что добавлю это для любого в подобной ситуации, в которой я находился.

31 голосов
/ 14 июня 2010

В MSDN есть запись в блоге о том, почему оператор степени не существует из команды C #.

Можно было бы добавить мощность оператор на язык, но выполнение этой операции является довольно редкая вещь, которую можно сделать в большинстве программ, и кажется неоправданным добавить оператор при вызове Math.Pow () простой.


Вы спросили:

Должен ли я написать цикл или включить другое пространство имен для обработки экспоненциальные операции? Если да, то как Я выполняю экспоненциальные операции, используя нецелые?

Math.Pow поддерживает двойные параметры, поэтому вам не нужно писать свои собственные.

5 голосов
/ 24 августа 2017

Отсутствие экспоненциального оператора для C # было большим раздражением для нас, когда мы искали новый язык для преобразования нашего программного обеспечения для вычислений из хорошего старого vb6.

Я рад, что мы пошли с C #но это все еще раздражает меня всякий раз, когда я пишу сложное уравнение, включающее показатели.Метод Math.Pow () затрудняет чтение уравнений IMO.

Нашим решением было создание специального класса DoubleX, в котором мы переопределяем оператор ^ (см. Ниже)

Это работает справедливоесли вы объявляете хотя бы одну из переменных как DoubleX:

DoubleX a = 2;
DoubleX b = 3;

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

или используете явный преобразователь для стандартных значений типа double:

double c = 2;
double d = 3;

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

Одна из проблем этого метода заключается в том, чтопоказатель степени рассчитывается в неправильном порядке по сравнению с другими операторами.Этого можно избежать, всегда помещая extra () вокруг операции, что снова затрудняет чтение уравнений:

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

Я надеюсь, что это может помочь другим, кто использует много сложныхуравнения в их коде, и, возможно, кто-то даже имеет представление о том, как улучшить этот метод ?!: -)

Класс 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 --------------
    }
}
2 голосов
/ 31 июля 2014

Я удивлен, что никто не упомянул об этом, но для простого (и, вероятно, наиболее часто встречающегося) случая возведения в квадрат вы просто умножаетесь на себя.

float Result, Number1;

Result = Number1 * Number1;
0 голосов
/ 09 июня 2016

Поскольку никто еще не написал функцию, которая делает это с двумя целыми числами, вот один из способов:

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

В качестве альтернативы в 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
...