Например, существует ли для этого оператор?
float Result, Number1, Number2;
Number1 = 2;
Number2 = 2;
Result = Number1 (operator) Number2;
В прошлом оператор ^ служил экспоненциальным оператором в других языках, но в С# он был побитным оператором.
Должен ли я писать цикл или включать другое пространство имен для обработки экспоненциальных операций? Если да, то как мне обрабатывать экспоненциальные операции с использованием нецелых чисел?
В языке С# нет оператора power. Однако .NET Framework предлагает метод Math.Pow :
Возвращает указанное число, возведенное в указанную степень.
Итак, ваш пример будет выглядеть так:
float Result, Number1, Number2;
Number1 = 2;
Number2 = 2;
Result = Math.Pow(Number1, Number2);
Я наткнулся на это сообщение, надеясь использовать научную нотацию в своем коде, я использовал
4.95*Math.Pow(10,-10);
Но потом я узнал, что вы можете сделать
4.95E-10;
Просто подумал, что добавлю это для кого-либо в подобной ситуации, в которой я был.
В MSDN есть блог о том, почему оператор степени не существует от команды С#.
Можно было бы добавить мощность оператор на язык, но выполнение этой операции является довольно редкая вещь, которую можно сделать в большинстве программ, и кажется неоправданным добавить оператор при вызове Math.Pow() простой.
Вы спросили:
Должен ли я написать цикл или включить другое пространство имен для обработки экспоненциальные операции? Если да, то как Я выполняю экспоненциальные операции, используя нецелые?
Math.Pow поддерживает двойные параметры, поэтому вам не нужно писать свои собственные.
Отсутствие экспоненциального оператора для С# было для нас большим раздражением при поиске нового языка для преобразования нашего программного обеспечения для расчета с хорошего ol vb6.
Я рад, что мы пошли с С#, но это все еще раздражает меня всякий раз, когда я пишу сложное уравнение, включающее экспоненты. Метод Math.Pow() делает уравнения довольно трудными для чтения IMO.
Наше решение заключалось в создании специального класса DoubleX, где мы переопределяем ^ -оператор (см. ниже)
Это работает достаточно хорошо, пока вы объявляете хотя бы одну из переменных как 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
Я надеюсь, что это может помочь другим, кто использует в своих кодах множество сложных уравнений, и, возможно, у кого-то даже есть идея, как улучшить этот метод?!: -)
Класс 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 --------------
}
}
Я удивлен, что никто не упомянул об этом, но для простого (и, вероятно, наиболее часто встречающегося) случая возведения в квадрат вы просто размножаетесь сами по себе.
float Result, Number1;
Result = Number1 * Number1;
Так как никто еще не написал функцию, чтобы сделать это с двумя целыми числами, здесь один способ:
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
Хорошая функция мощности будет
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;
}
}
Функция "Math.Pow" использует функцию мощности процессора и является более эффективной.