C#で累乗を計算する方法｜Math.Powの使い方からint型・小数・べき乗演算子の疑問まで解説
はじめに
C#で累乗を計算したいときは、基本的にMath.Powメソッドを使います。たとえば「2の3乗」「10の2乗」「小数の累乗」「負の指数」などは、Math.Powを使うことで簡単に計算できます。
一方で、C#にはPythonの**のような累乗専用の演算子はありません。また、^を累乗だと思って使うと、想定外の結果になります。C#の^は累乗ではなくXOR演算子です。
この記事では、C#で累乗を計算する基本から、Math.Powの使い方、int型で結果を扱う方法、小数計算での注意点、よくあるエラーまで解説します。
1. C#で累乗を計算する基本
1-1. 累乗・べき乗とは何か
累乗とは、同じ数を何回か掛け合わせる計算のことです。べき乗とも呼ばれます。
たとえば、2の3乗は次のような計算です。
C#2 × 2 × 2 = 8
このとき、2を「底」、3を「指数」と呼びます。
数学では次のように表します。
2^3 = 8
ただし、C#ではこの書き方をそのまま累乗として使うことはできません。C#で累乗を計算する場合は、主にMath.Powを使います。
1-2. C#で累乗を計算するならMath.Powを使う
C#で累乗を計算する基本的な方法は、Math.Powメソッドを使うことです。
C#double result = Math.Pow(2, 3);
Console.WriteLine(result);
実行結果は次のようになります。
8
Math.Pow(2, 3)は「2の3乗」を意味します。
つまり、次の計算と同じです。
C#2 * 2 * 2
Math.Powを使えば、指数の値を変数にしたり、小数や負の指数を扱ったりできるため、汎用的な累乗計算に向いています。
1-3. 「2の3乗」「10の2乗」をC#で書く基本コード
「2の3乗」をC#で書くと、次のようになります。
C#double result1 = Math.Pow(2, 3);
Console.WriteLine(result1);
実行結果は次のとおりです。
8
「10の2乗」を計算する場合は、次のように書きます。
C#double result2 = Math.Pow(10, 2);
Console.WriteLine(result2);
実行結果は次のとおりです。
100
Math.Pow(底, 指数)という形で覚えるとわかりやすいです。
2. Math.Powの使い方
2-1. Math.Powの基本構文
Math.Powの基本構文は次のとおりです。
C#Math.Pow(底, 指数)
実際のコードでは、次のように使います。
C#double result = Math.Pow(5, 3);
Console.WriteLine(result);
このコードは「5の3乗」を計算します。
5 × 5 × 5 = 125
実行結果は次のようになります。
125
2-2. 第1引数は底、第2引数は指数
Math.Powでは、第1引数に底、第2引数に指数を指定します。
C#Math.Pow(2, 3)
これは「2の3乗」です。
2 × 2 × 2 = 8
反対に、次のコードは「3の2乗」になります。
C#Math.Pow(3, 2)
実行結果は次のとおりです。
9
引数の順番を間違えると結果が変わるため注意しましょう。
C#Console.WriteLine(Math.Pow(2, 3)); // 8
Console.WriteLine(Math.Pow(3, 2)); // 9
2-3. Math.Powの戻り値はdouble型
Math.Powの戻り値はdouble型です。
そのため、整数同士の累乗であっても結果はdoubleとして返されます。
C#double result = Math.Pow(2, 3);
Console.WriteLine(result);
実行結果は次のようになります。
8
見た目は整数のように見えますが、型はdoubleです。
そのため、次のようにint型の変数にそのまま代入することはできません。
C#int result = Math.Pow(2, 3); // エラー
int型で扱いたい場合は、明示的にキャストする必要があります。
C#int result = (int)Math.Pow(2, 3);
Console.WriteLine(result);
2-4. using Systemが必要な場合と不要な場合
MathクラスはSystem名前空間に含まれています。
そのため、ファイルの先頭に次の記述があれば、Math.Powと書けます。
C#using System;
コード例は次のとおりです。
C#using System;
class Program
{
static void Main()
{
double result = Math.Pow(2, 3);
Console.WriteLine(result);
}
}
using System;を書かない場合は、次のように完全修飾名で書くこともできます。
C#double result = System.Math.Pow(2, 3);
最近のC#プロジェクトでは、暗黙的なusingによってSystemが自動的に使える場合もあります。ただし、環境やプロジェクト設定によって異なるため、Math.Powが認識されない場合はusing System;を確認しましょう。
3. Math.Powを使った累乗計算のサンプル
3-1. 整数の累乗を計算する
整数の累乗を計算する基本例です。
C#double result = Math.Pow(4, 3);
Console.WriteLine(result);
実行結果は次のとおりです。
64
これは次の計算と同じです。
4 × 4 × 4 = 64
変数を使って書くこともできます。
C#int baseNumber = 4;
int exponent = 3;
double result = Math.Pow(baseNumber, exponent);
Console.WriteLine(result);
指数を変数にできるため、ユーザー入力や計算結果に応じて累乗を求めたい場合にも便利です。
3-2. 小数の累乗を計算する
Math.Powでは、小数の累乗も計算できます。
C#double result = Math.Pow(1.5, 2);
Console.WriteLine(result);
実行結果は次のようになります。
2.25
これは次の計算と同じです。
1.5 × 1.5 = 2.25
指数に小数を指定することもできます。
C#double result = Math.Pow(9, 0.5);
Console.WriteLine(result);
実行結果は次のとおりです。
3
0.5乗は平方根と同じ意味になります。ただし、平方根を求めたい場合は、より意図が明確なMath.Sqrtを使うことが一般的です。
C#double result = Math.Sqrt(9);
Console.WriteLine(result);
3-3. 負の数の累乗を計算する
負の数を底にすることもできます。
C#double result = Math.Pow(-2, 3);
Console.WriteLine(result);
実行結果は次のとおりです。
-8
これは次の計算と同じです。
-2 × -2 × -2 = -8
指数が偶数の場合は、結果が正の数になります。
C#Console.WriteLine(Math.Pow(-2, 2)); // 4
Console.WriteLine(Math.Pow(-2, 4)); // 16
指数が奇数の場合は、結果が負の数になります。
C#Console.WriteLine(Math.Pow(-2, 3)); // -8
Console.WriteLine(Math.Pow(-2, 5)); // -32
ただし、負の数に小数の指数を指定すると、NaNになる場合があります。
C#double result = Math.Pow(-2, 0.5);
Console.WriteLine(result);
このような計算は実数の範囲では扱えないため、結果がNaNになることがあります。
3-4. 0乗・1乗・負の指数を計算する
任意の数の0乗は、基本的に1になります。
C#Console.WriteLine(Math.Pow(5, 0)); // 1
Console.WriteLine(Math.Pow(10, 0)); // 1
1乗は元の値のままです。
C#Console.WriteLine(Math.Pow(5, 1)); // 5
Console.WriteLine(Math.Pow(10, 1)); // 10
負の指数も計算できます。
C#double result = Math.Pow(2, -3);
Console.WriteLine(result);
実行結果は次のようになります。
0.125
これは次の計算と同じです。
1 / (2 × 2 × 2) = 1 / 8 = 0.125
負の指数を使うと、分数のような結果になるため、戻り値がdoubleであることを意識しておきましょう。
4. int型で累乗の結果を扱う方法
4-1. Math.Powの結果をintに変換する方法
Math.Powの戻り値はdouble型です。そのため、int型の変数に代入したい場合はキャストが必要です。
C#int result = (int)Math.Pow(2, 3);
Console.WriteLine(result);
実行結果は次のとおりです。
8
ただし、キャストすると小数点以下が切り捨てられます。
C#int result = (int)Math.Pow(2, -3);
Console.WriteLine(result);
Math.Pow(2, -3)は0.125ですが、intにキャストすると0になります。
0
整数の累乗結果だけを扱う場合は問題になりにくいですが、負の指数や小数の累乗を扱う場合は注意が必要です。
4-2. キャスト時に小数点以下が切り捨てられる点に注意
doubleからintへキャストすると、小数点以下は四捨五入されずに切り捨てられます。
C#double value = 3.9;
int result = (int)value;
Console.WriteLine(result);
実行結果は次のとおりです。
3
これはMath.Powの結果でも同じです。
C#double powResult = Math.Pow(1.5, 2); // 2.25
int intResult = (int)powResult;
Console.WriteLine(intResult);
実行結果は次のようになります。
2
四捨五入したい場合は、単純なキャストではなくMath.Roundを使います。
4-3. Math.Round・Math.Floor・Math.Ceilingとの使い分け
Math.Powの結果を整数に近づけたい場合、目的に応じてMath.Round、Math.Floor、Math.Ceilingを使い分けます。
四捨五入したい場合はMath.Roundを使います。
C#double value = Math.Pow(1.5, 2); // 2.25
double rounded = Math.Round(value);
Console.WriteLine(rounded);
小数点以下を切り捨てたい場合はMath.Floorを使います。
C#double value = 2.9;
double floor = Math.Floor(value);
Console.WriteLine(floor); // 2
小数点以下を切り上げたい場合はMath.Ceilingを使います。
C#double value = 2.1;
double ceiling = Math.Ceiling(value);
Console.WriteLine(ceiling); // 3
int型として扱いたい場合は、丸め処理をしたあとにキャストします。
C#int result = (int)Math.Round(Math.Pow(1.5, 2));
Console.WriteLine(result);
単純に整数へ変換するだけならキャスト、四捨五入したいならMath.Round、常に下方向へ丸めたいならMath.Floor、常に上方向へ丸めたいならMath.Ceilingを使うとよいでしょう。
4-4. int型で扱う場合のオーバーフローに注意
int型には扱える範囲があります。非常に大きな累乗をintに変換すると、オーバーフローに注意が必要です。
たとえば、intの最大値を超えるような値を扱う場合、正しい結果にならない可能性があります。
C#double powResult = Math.Pow(100000, 3);
int intResult = (int)powResult;
Console.WriteLine(intResult);
大きな累乗を扱う場合は、longやdouble、必要に応じてBigIntegerの使用を検討します。
C#long result = (long)Math.Pow(1000, 3);
Console.WriteLine(result);
さらに大きな整数計算が必要な場合は、System.Numerics.BigIntegerを使う方法もあります。
C#using System;
using System.Numerics;
class Program
{
static void Main()
{
BigInteger result = BigInteger.Pow(100000, 3);
Console.WriteLine(result);
}
}
整数として正確に大きな累乗を扱いたい場合は、Math.PowよりもBigInteger.Powの方が適しているケースがあります。
5. C#に累乗演算子はあるのか
5-1. C#には累乗専用の演算子はない
C#には、累乗専用の演算子はありません。
たとえば、Pythonでは次のように**で累乗を計算できます。
Pythonresult = 2 ** 3
しかし、C#では次のようには書けません。
C#int result = 2 ** 3; // エラー
C#で累乗を計算する場合は、基本的にMath.Powを使います。
C#double result = Math.Pow(2, 3);
5-2. 「^」は累乗ではなくXOR演算子
C#で特に間違いやすいのが、^を累乗演算子だと思って使ってしまうケースです。
C#int result = 2 ^ 3;
Console.WriteLine(result);
この結果は8ではありません。
1
C#の^は累乗ではなく、ビット演算のXOR演算子です。
そのため、次のようなコードは「2の3乗」ではありません。
C#int result = 2 ^ 3; // 累乗ではない
「2の3乗」を計算したい場合は、次のように書きます。
C#double result = Math.Pow(2, 3);
5-3. PythonやVB.NETとの違い
言語によって累乗の書き方は異なります。
Pythonでは**を使います。
Pythonresult = 2 ** 3
VB.NETでは^が累乗演算子として使われます。
VB.NETDim result = 2 ^ 3
しかし、C#では^はXOR演算子です。
C#int result = 2 ^ 3; // XOR
C#では、累乗を計算したい場合に^を使わないようにしましょう。
C#double result = Math.Pow(2, 3);
他のプログラミング言語の書き方に慣れている人ほど、C#で^を使ってしまいやすいので注意が必要です。
5-4. 累乗したい場合はMath.Powを使うべき理由
C#で累乗を計算する場合にMath.Powを使うべき理由は、意図が明確だからです。
C#double result = Math.Pow(2, 3);
このコードを見れば、「2の3乗を計算している」とすぐにわかります。
また、Math.Powは次のような計算にも対応できます。
C#Math.Pow(2, 3); // 整数の累乗
Math.Pow(1.5, 2); // 小数の累乗
Math.Pow(2, -3); // 負の指数
Math.Pow(9, 0.5); // 小数の指数
2乗や3乗のように単純な場合は掛け算でも書けますが、汎用的な累乗計算ではMath.Powを使うのが基本です。
6. 2乗・3乗だけなら掛け算でも計算できる
6-1. x * xで2乗を計算する方法
2乗だけを計算したい場合は、Math.Powを使わずに掛け算で書くこともできます。
C#int x = 5;
int result = x * x;
Console.WriteLine(result);
実行結果は次のとおりです。
25
このコードは、次の計算と同じです。
5 × 5 = 25
2乗だけであれば、x * xの方がシンプルでわかりやすい場合があります。
6-2. x * x * xで3乗を計算する方法
3乗も掛け算で書けます。
C#int x = 5;
int result = x * x * x;
Console.WriteLine(result);
実行結果は次のとおりです。
125
これは次の計算と同じです。
5 × 5 × 5 = 125
3乗程度であれば、Math.Powを使わずに直接掛け算する方法もよく使われます。
6-3. Math.Powと掛け算の使い分け
Math.Powと掛け算は、目的に応じて使い分けるとよいです。
指数が固定で、2乗や3乗だけを計算するなら、掛け算がわかりやすい場合があります。
C#int square = x * x;
int cube = x * x * x;
一方、指数が変数になる場合はMath.Powが適しています。
C#int x = 2;
int n = 10;
double result = Math.Pow(x, n);
Console.WriteLine(result);
指数をユーザー入力で受け取る場合も、Math.Powの方が扱いやすいです。
C#int baseNumber = 2;
int exponent = 5;
double result = Math.Pow(baseNumber, exponent);
Console.WriteLine(result);
2乗や3乗だけなら掛け算、指数が変わるならMath.Powと考えるとよいでしょう。
6-4. 処理速度や可読性を考えた選び方
2乗や3乗のような単純な計算では、掛け算の方が軽量です。
C#double square = x * x;
一方で、指数が変化する場合は、掛け算で書くとコードが複雑になります。
C#double result = Math.Pow(x, exponent);
可読性を重視するなら、何を計算しているかが明確に伝わる書き方を選ぶことが大切です。
たとえば、座標計算などで2乗を使う場合は、次のように書くと簡潔です。
C#double distanceSquared = dx * dx + dy * dy;
汎用的なべき乗計算であれば、次のようにMath.Powを使うと意図が明確です。
C#double result = Math.Pow(baseNumber, exponent);
速度だけでなく、読みやすさや保守しやすさも考えて選びましょう。
7. Math.Powを使うときの注意点
7-1. 戻り値がdoubleになるため誤差が出る場合がある
Math.Powの戻り値はdoubleです。doubleは浮動小数点数なので、計算結果にわずかな誤差が出る場合があります。
たとえば、小数を含む計算では、数学的にはきれいな値になるはずでも、内部的には完全に一致しないことがあります。
C#double result = Math.Pow(0.1, 2);
Console.WriteLine(result);
このような小数計算では、表示上は問題ないように見えても、比較や丸め処理で注意が必要です。
C#double a = Math.Pow(0.1, 2);
double b = 0.01;
Console.WriteLine(a == b);
浮動小数点数を比較するときは、完全一致ではなく、誤差の範囲を考慮する方法がよく使われます。
C#double a = Math.Pow(0.1, 2);
double b = 0.01;
double tolerance = 0.0000001;
Console.WriteLine(Math.Abs(a - b) < tolerance);
7-2. 小数計算では浮動小数点誤差に注意する
doubleは多くの数値計算で便利ですが、小数を正確に表せない場合があります。
C#double value = 0.1 + 0.2;
Console.WriteLine(value);
実行結果が、期待する0.3と完全には一致しないことがあります。
Math.Powでも同様に、小数を扱う場合は浮動小数点誤差を意識する必要があります。
C#double result = Math.Pow(1.1, 3);
Console.WriteLine(result);
計算結果を表示するだけなら大きな問題にならないこともありますが、条件分岐や比較に使う場合は注意しましょう。
C#double result = Math.Pow(1.1, 3);
if (Math.Abs(result - 1.331) < 0.000001)
{
Console.WriteLine("ほぼ等しい");
}
小数の累乗を扱う場合は、「完全に一致するか」ではなく「許容範囲内か」で判断するのが安全です。
7-3. 金額計算ではdecimal型の扱いに注意する
金額計算では、doubleではなくdecimalが使われることが多いです。
C#decimal price = 1000m;
decimal taxRate = 1.1m;
decimal total = price * taxRate;
Console.WriteLine(total);
しかし、Math.Powはdecimalではなくdoubleを扱います。
そのため、decimalの値をMath.Powに渡す場合は、doubleへ変換する必要があります。
C#decimal value = 1.05m;
double result = Math.Pow((double)value, 2);
Console.WriteLine(result);
ただし、decimalからdoubleへ変換すると精度の扱いが変わります。金額計算で累乗が必要な場合は、どの程度の精度が必要かを考えて実装する必要があります。
単純な複利計算などであれば、最後に丸め処理を行うこともあります。
C#decimal principal = 10000m;
double rate = 1.05;
int years = 3;
decimal result = principal * (decimal)Math.Pow(rate, years);
result = Math.Round(result, 0);
Console.WriteLine(result);
金額計算では、Math.Powを使う前後でdecimalとdoubleの変換が発生する点に注意しましょう。
7-4. NaNやInfinityになるケースを理解する
Math.Powの計算結果は、条件によってNaNやInfinityになる場合があります。
NaNは「数値ではない」ことを表します。
たとえば、負の数に小数の指数を指定すると、実数として計算できずNaNになる場合があります。
C#double result = Math.Pow(-1, 0.5);
Console.WriteLine(result);
結果がNaNかどうかは、double.IsNaNで判定できます。
C#double result = Math.Pow(-1, 0.5);
if (double.IsNaN(result))
{
Console.WriteLine("計算結果はNaNです");
}
非常に大きな数を計算すると、Infinityになる場合があります。
C#double result = Math.Pow(10, 1000);
Console.WriteLine(result);
Infinityかどうかは、double.IsInfinityで判定できます。
C#double result = Math.Pow(10, 1000);
if (double.IsInfinity(result))
{
Console.WriteLine("計算結果はInfinityです");
}
大きな累乗や特殊な値を扱う場合は、NaNやInfinityの判定を入れておくと安全です。
8. よくあるエラーと疑問
8-1. Math.Powが使えないときの原因
Math.Powが使えない場合、まずSystem名前空間が使える状態か確認しましょう。
C#using System;
コード全体の例は次のとおりです。
C#using System;
class Program
{
static void Main()
{
double result = Math.Pow(2, 3);
Console.WriteLine(result);
}
}
using System;を書かない場合は、次のように書けます。
C#double result = System.Math.Pow(2, 3);
また、Mathのスペルミスにも注意しましょう。
C#double result = Math.Pow(2, 3); // 正しい
次のような書き方は誤りです。
C#double result = math.Pow(2, 3); // エラー
C#は大文字と小文字を区別するため、Mathは先頭を大文字で書く必要があります。
8-2. intに代入できないエラーの対処法
Math.Powの結果をintに直接代入するとエラーになります。
C#int result = Math.Pow(2, 3); // エラー
理由は、Math.Powの戻り値がdouble型だからです。
対処法として、明示的にキャストします。
C#int result = (int)Math.Pow(2, 3);
Console.WriteLine(result);
ただし、小数点以下がある場合は切り捨てられます。
C#int result = (int)Math.Pow(1.5, 2);
Console.WriteLine(result); // 2
四捨五入してからintにしたい場合は、Math.Roundを使います。
C#int result = (int)Math.Round(Math.Pow(1.5, 2));
Console.WriteLine(result);
整数の範囲を超える可能性がある場合は、longやBigIntegerも検討しましょう。
8-3. 「^」を使ったら想定外の結果になる理由
C#で次のように書いても、累乗にはなりません。
C#int result = 2 ^ 3;
Console.WriteLine(result);
実行結果は次のようになります。
1
これは、^がXOR演算子だからです。
C#で「2の3乗」を計算したい場合は、次のように書きます。
C#double result = Math.Pow(2, 3);
Console.WriteLine(result);
実行結果は次のとおりです。
8
C#では、^を累乗として使わないようにしましょう。
8-4. ルート計算や平方根を求めたい場合
平方根を求めたい場合は、Math.Sqrtを使います。
C#double result = Math.Sqrt(9);
Console.WriteLine(result);
実行結果は次のとおりです。
3
Math.Powでも平方根を求めることはできます。
C#double result = Math.Pow(9, 0.5);
Console.WriteLine(result);
ただし、平方根を求める目的であれば、Math.Sqrtを使った方が意図がわかりやすいです。
C#double sqrt = Math.Sqrt(16);
Console.WriteLine(sqrt); // 4
立方根を求めたい場合は、Math.Powで1.0 / 3.0乗を使う方法があります。
C#double result = Math.Pow(27, 1.0 / 3.0);
Console.WriteLine(result);
平方根ならMath.Sqrt、一般的な累乗やn乗根ならMath.Powを使うとよいでしょう。
9. C#の累乗計算に関するFAQ
9-1. C#で2の10乗を計算するには？
C#で2の10乗を計算するには、Math.Pow(2, 10)を使います。
C#double result = Math.Pow(2, 10);
Console.WriteLine(result);
実行結果は次のとおりです。
1024
int型で扱いたい場合は、キャストします。
C#int result = (int)Math.Pow(2, 10);
Console.WriteLine(result);
2の10乗のように結果が整数で、intの範囲に収まることがわかっている場合は、このように書けます。
9-2. C#で小数の累乗は計算できる？
C#では、Math.Powを使って小数の累乗を計算できます。
C#double result = Math.Pow(1.5, 2);
Console.WriteLine(result);
実行結果は次のとおりです。
2.25
指数に小数を指定することもできます。
C#double result = Math.Pow(9, 0.5);
Console.WriteLine(result);
実行結果は次のとおりです。
3
ただし、小数計算では浮動小数点誤差が発生する場合があります。比較や金額計算に使う場合は注意しましょう。
9-3. C#でint型のまま累乗計算できる？
Math.Powの戻り値はdoubleなので、int型のまま結果を受け取ることはできません。
C#int result = Math.Pow(2, 3); // エラー
intとして扱いたい場合は、キャストします。
C#int result = (int)Math.Pow(2, 3);
Console.WriteLine(result);
2乗や3乗だけであれば、intの掛け算で計算できます。
C#int x = 5;
int square = x * x;
int cube = x * x * x;
Console.WriteLine(square);
Console.WriteLine(cube);
整数の累乗を正確に扱いたい場合は、自分で整数用の累乗関数を作る方法もあります。
C#static int IntPow(int baseNumber, int exponent)
{
int result = 1;
for (int i = 0; i < exponent; i++)
{
result *= baseNumber;
}
return result;
}
使用例は次のとおりです。
C#int result = IntPow(2, 10);
Console.WriteLine(result);
ただし、大きな累乗ではオーバーフローに注意が必要です。
9-4. C#でべき乗演算子を自作できる？
C#では、Pythonの**のような新しい演算子を自由に追加することはできません。
そのため、累乗演算子そのものを自作することはできません。
ただし、累乗用のメソッドを自作することはできます。
C#static double Pow(double baseNumber, double exponent)
{
return Math.Pow(baseNumber, exponent);
}
使用例は次のとおりです。
C#double result = Pow(2, 3);
Console.WriteLine(result);
整数専用の累乗メソッドを作ることもできます。
C#static int IntPow(int baseNumber, int exponent)
{
int result = 1;
for (int i = 0; i < exponent; i++)
{
result *= baseNumber;
}
return result;
}
ただし、通常は標準のMath.Powを使う方がわかりやすく、他の開発者にも意図が伝わりやすいです。
9-5. Math.PowとMath.Sqrtの違いは？
Math.Powは累乗を計算するためのメソッドです。
C#double result = Math.Pow(2, 3); // 2の3乗
Console.WriteLine(result);
一方、Math.Sqrtは平方根を求めるためのメソッドです。
C#double result = Math.Sqrt(9); // √9
Console.WriteLine(result);
Math.Pow(9, 0.5)でも平方根を求めることはできます。
C#double result = Math.Pow(9, 0.5);
Console.WriteLine(result);
ただし、平方根を求めたい場合は、Math.Sqrtの方が意図が明確です。
C#double sqrt = Math.Sqrt(9);
累乗全般にはMath.Pow、平方根にはMath.Sqrtを使うと覚えておくとよいでしょう。
まとめ
C#で累乗を計算する場合は、基本的にMath.Powを使います。
C#double result = Math.Pow(2, 3);
Math.Powは第1引数に底、第2引数に指数を指定します。
C#Math.Pow(底, 指数)
たとえば、2の3乗は次のように書きます。
C#double result = Math.Pow(2, 3);
C#には累乗専用の演算子はありません。^は累乗ではなくXOR演算子なので注意が必要です。
C#int result = 2 ^ 3; // 累乗ではない
2乗や3乗だけであれば、掛け算で書くこともできます。
C#int square = x * x;
int cube = x * x * x;
一方で、指数が変数になる場合や小数、負の指数を扱う場合は、Math.Powが便利です。
ただし、Math.Powの戻り値はdoubleです。int型で扱いたい場合はキャストが必要で、小数点以下の切り捨てやオーバーフローに注意する必要があります。
C#int result = (int)Math.Pow(2, 3);
また、小数の累乗では浮動小数点誤差が出る場合があります。金額計算や厳密な比較では、丸め処理やdecimal型との変換に注意しましょう。
C#で累乗を扱うときは、基本はMath.Pow、2乗や3乗だけなら掛け算、平方根ならMath.Sqrtというように、目的に合わせて使い分けることが大切です。