Есть ли оператор экспоненты в C#?

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

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

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

4.95E-10;

просто подумал, что я бы добавил Это для всех, кто находится в подобной ситуации, в которой я был.

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

можно было бы добавить мощности оператор к языку, но выполнение этой операции является довольно редкая вещь, чтобы сделать в большинстве программ, и это не кажется оправданным добавить оператор при вызове математика.Бах () is простой.

---

ты спрашиваешь:

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

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

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

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

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

этот работает довольно хорошо, как долго, как вы заявляете, по крайней мере, одну из переменных как квартира в жилом доме:

DoubleX a = 2;
DoubleX b = 3;

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

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

double c = 2;
double d = 3;

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

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

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

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

класса квартира в жилом доме:

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 --------------
    }
}

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

float Result, Number1;

Result = Number1 * Number1;

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

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

альтернативно в 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