226

例如，是否存在操作员来处理此问题？

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Number1 (operator) Number2;

过去，^运算符在其他语言中用作指数运算符，但在 C# 中，它是按位运算符。

我是否必须编写一个循环或包含另一个命名空间来处理指数运算？如果是这样，我如何使用非整数处理指数运算？

4

9 回答 9

271

C# 语言没有幂运算符。但是，.NET Framework 提供了以下Math.Pow方法：

返回指定数字的指定幂。

所以你的例子看起来像这样：

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Math.Pow(Number1, Number2);
于 2010-06-14T01:32:34.080 回答
61

我偶然发现这篇文章希望在我的代码中使用科学记数法，我用过

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

但后来我发现你可以做到

4.95E-10;

只是想我会为与我处于类似情况的任何人添加此内容。

于 2014-01-11T05:47:47.500 回答
35

MSDN 上有一篇关于C# 团队为什么不存在指数运算符的博客文章。

可以在语言中添加幂运算符，但是在大多数程序中执行此操作是相当罕见的事情，并且在调用Math.Pow () 很简单时添加运算符似乎不合理。

您问：

我是否必须编写一个循环或包含另一个命名空间来处理指数运算？如果是这样，我如何使用非整数处理指数运算？

Math.Pow支持双参数，所以不需要你自己写。

于 2010-06-14T01:36:25.840 回答
14

在寻找一种新语言来将我们的计算软件从好的 ol' vb6 转换为 C# 时，C# 缺少指数运算符对我们来说是一个很大的烦恼。

我很高兴我们使用 C#，但每当我编写一个包含指数的复杂方程时，它仍然让我烦恼。该Math.Pow()方法使方程式很难阅读 IMO。

我们的解决方案是创建一个特殊的DoubleX类，我们在其中覆盖^-operator（见下文）

只要您将至少一个变量声明为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 --------------
    }
}
于 2017-08-24T07:19:29.773 回答
2

我很惊讶没有人提到这一点，但是对于简单的（可能是最常见的）平方的情况，你只需乘以它自己。

float someNumber;

float result = someNumber * someNumber;
于 2014-07-31T04:23:01.400 回答
2

由于还没有人写过一个函数来用两个整数来做这件事，这里有一种方法：

private static long CalculatePower(int number, int powerOf)
{
    long result = number;
    for (int i = 2; i <= powerOf; i++)
        result *= number;
    return result;
}

或者在 VB.NET 中：

Private Function CalculatePower(ByVal number As Integer, ByVal powerOf As Integer) As Long
    Dim result As Long = number
    For i As Integer = 2 To powerOf
        result = result * number
    Next
    Return result
End Function
CalculatePower(5, 3) ' 125
CalculatePower(8, 4) ' 4096
CalculatePower(6, 2) ' 36
于 2016-06-09T12:58:21.833 回答
1

For what it's worth I do miss the ^ operator when raising a power of 2 to define a binary constant. Can't use Math.Pow() there, but shifting an unsigned int of 1 to the left by the exponent's value works. When I needed to define a constant of (2^24)-1:

public static int Phase_count = 24;
public static uint PatternDecimal_Max = ((uint)1 << Phase_count) - 1;

Remember the types must be (uint) << (int).

于 2020-03-14T02:10:41.633 回答
0

它不是运算符，但您可以编写自己的扩展函数。

public static double Pow(this double value, double exponent)
{
    return Math.Pow(value, exponent);
}

这允许你写

a.Pow(b);

代替

Math.Pow(a, b);

我认为这使 a 和 ba 之间的关系更加清晰+您避免一遍又一遍地写“数学”。

于 2021-08-30T10:02:33.550 回答
-1

一个好的幂函数是

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函数使用处理器功率函数，效率更高。

于 2019-09-05T08:33:54.803 回答