226

たとえば、これを処理するためのオペレーターは存在しますか？

float Result, Number1, Number2;

Number1 = 2;
Number2 = 2;

Result = Number1 (operator) Number2;

過去には、^演算子は他の言語では指数演算子として機能していましたが、C＃ではビット単位の演算子です。

指数演算を処理するために、ループを作成するか、別の名前空間を含める必要がありますか？もしそうなら、非整数を使用して指数演算を処理するにはどうすればよいですか？

4

9 に答える 9

271

C＃言語にはパワー演算子がありません。ただし、.NETFrameworkは次の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

指数演算子がC＃チームに存在しない理由について、MSDNにブログ投稿があります。

言語にパワー演算子を追加することは可能ですが、この操作を実行することはほとんどのプログラムで非常にまれなことであり、 Math.Pow（）を呼び出すときに演算子を追加することは正当ではないようです。

あなたは尋ねました：

指数演算を処理するために、ループを作成するか、別の名前空間を含める必要がありますか？もしそうなら、非整数を使用して指数演算を処理するにはどうすればよいですか？

Math.Powダブルパラメータをサポートしているので、独自に作成する必要はありません。

于 2010-06-14T01:36:25.840 に答える
14

C＃の指数演算子がないことは、計算ソフトウェアを古き良きvb6から変換するための新しい言語を探すときに私たちにとって大きな悩みの種でした。

C＃を使用してよかったのですが、指数を含む複雑な方程式を書いているときはいつでも、それでもイライラします。このMath.Pow()方法では、方程式をIMOで読み取るのが非常に困難になります。

DoubleX私たちの解決策は、-operatorをオーバーライドする特別なクラスを作成することでした^（以下を参照）

少なくとも1つの変数を次のように宣言する限り、これはかなりうまく機能します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

ただし、この方法の問題の1つは、指数が他の演算子と比較して間違った順序で計算されることです。これは、操作の周りに常に余分なものを配置することで回避できます。これにより( )、方程式を読むのが少し難しくなります。

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

2つの整数でこれを行う関数をまだ作成している人はいないため、次の1つの方法があります。

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

バイナリ定数を定義するために2の累乗を上げるとき、私は^演算子を見逃す価値があります。そこでMath.Pow（）を使用することはできませんが、指数の値によって1のunsignedintを左にシフトすることはできます。（2 ^ 24）-1の定数を定義する必要がある場合：

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

タイプは（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 に答える