C#で累乗を計算する方法｜Math.Powの使い方・戻り値double・^演算子との違いを解説

はじめに

C#で累乗を計算するときは、基本的にMath.Powメソッドを使用します。たとえば「2の3乗」を求める場合は、次のように記述します。

double result = Math.Pow(2, 3);Console.WriteLine(result); // 8

ただし、Math.Powの戻り値は整数ではなくdouble型です。また、C#の^演算子は累乗を表すものではありません。2 ^ 3と書いても、計算結果は8にならないため注意が必要です。

この記事では、C#で累乗を計算する基本から、Math.Powの使い方、戻り値をint型へ変換する方法、^演算子との違い、自前で累乗を計算する方法まで詳しく解説します。

1. C#で累乗を計算する基本

1-1. 累乗とは「同じ数を何回か掛ける計算」

累乗とは、同じ数を指定された回数だけ掛ける計算です。

たとえば、2の3乗は次の計算を意味します。

2³ = 2 × 2 × 2 = 8

累乗では、掛ける数を「底」、掛ける回数を「指数」と呼びます。

2³↑ ↑底 指数

代表的な例は次のとおりです。

2の2乗 = 2 × 2 = 42の3乗 = 2 × 2 × 2 = 85の2乗 = 5 × 5 = 2510の3乗 = 10 × 10 × 10 = 1000

指数が2の場合は「2乗」または「平方」、指数が3の場合は「3乗」または「立方」と呼ばれます。

1-2. C#で累乗を求める標準的な方法はMath.Pow

C#で累乗を求める標準的な方法は、System.MathクラスのPowメソッドを使用することです。

double result = Math.Pow(底, 指数);

たとえば、2の3乗は次のように計算できます。

double result = Math.Pow(2, 3);Console.WriteLine(result); // 8

Math.Powは、整数だけでなく小数や負の指数も扱えます。

Console.WriteLine(Math.Pow(2, -1));  // 0.5Console.WriteLine(Math.Pow(9, 0.5)); // 3

1-3. 「2の3乗」「10の2乗」など基本例で理解する

よく使われる累乗計算をMath.Powで記述すると、次のようになります。

Console.WriteLine(Math.Pow(2, 3));  // 8Console.WriteLine(Math.Pow(10, 2)); // 100Console.WriteLine(Math.Pow(5, 3));  // 125Console.WriteLine(Math.Pow(3, 4));  // 81

Math.Powの第1引数には底、第2引数には指数を指定します。

Math.Pow(2, 3);

このコードでは、2が底、3が指数です。引数の順番を反対にすると別の計算になります。

Console.WriteLine(Math.Pow(2, 3)); // 2の3乗：8Console.WriteLine(Math.Pow(3, 2)); // 3の2乗：9

1-4. C#には累乗専用の演算子がない点に注意

C#には、累乗専用の演算子がありません。

一部のプログラミング言語では**や^を累乗に使用しますが、C#では次の書き方はできません。

// C#では累乗として使用できない// int result = 2 ** 3;

また、次の^は累乗ではなく、ビット単位の排他的論理和を表します。

int result = 2 ^ 3;Console.WriteLine(result); // 1

C#で累乗を計算したい場合は、原則としてMath.Powを使用しましょう。

2. Math.Powを使って累乗を計算する方法

2-1. Math.Powの基本構文

Math.Powの基本構文は次のとおりです。

double 結果 = Math.Pow(底, 指数);

実際のコードでは、次のように使用します。

double result = Math.Pow(4, 3);Console.WriteLine(result); // 64

Math.Powの戻り値は常にdouble型です。

2-2. Math.Pow(底, 指数)の引数の意味

Math.Powは2つの引数を受け取ります。

Math.Pow(x, y);

それぞれの意味は次のとおりです。

x：底y：指数

Math.Pow(x, y)は、「xのy乗」を計算します。

double result = Math.Pow(3, 4);

この場合、計算内容は次のとおりです。

3 × 3 × 3 × 3 = 81

引数はどちらもdouble型として扱われるため、小数を指定することもできます。

double result = Math.Pow(2.5, 2);Console.WriteLine(result); // 6.25

2-3. using System; を使う書き方

一般的なC#プログラムでは、ファイルの先頭にusing System;を記述します。

using System;
class Program{static void Main(){double result = Math.Pow(2, 3);
    Console.WriteLine(result);}}

MathクラスとConsoleクラスはSystem名前空間に含まれています。using System;を記述すると、System.MathやSystem.ConsoleのSystem.部分を省略できます。

なお、最近の.NETプロジェクトでは暗黙的なusingが有効になっていることがあり、ファイル内にusing System;を書かなくてもコンパイルできる場合があります。

2-4. System.Math.Powと省略せずに書く方法

using System;を使わず、名前空間を含めて記述することもできます。

class Program{static void Main(){double result = System.Math.Pow(2, 3);
    System.Console.WriteLine(result);}}

Math.PowとSystem.Math.Powの計算内容に違いはありません。

通常はusing System;を指定してMath.Powと書くほうが簡潔ですが、同じ名前のクラスが存在して区別したい場合などには、System.Math.Powと完全修飾名で記述できます。

2-5. Console.WriteLineで計算結果を表示するサンプルコード

次のプログラムでは、底と指数を変えながら複数の累乗を表示しています。

using System;
class Program{static void Main(){double result1 = Math.Pow(2, 3);double result2 = Math.Pow(10, 2);double result3 = Math.Pow(5, 4);
    Console.WriteLine($"2の3乗は{result1}です");Console.WriteLine($"10の2乗は{result2}です");Console.WriteLine($"5の4乗は{result3}です");}}

実行結果は次のとおりです。

2の3乗は8です10の2乗は100です5の4乗は625です

計算結果をそのまま表示するだけなら、変数を用意せずに記述することもできます。

Console.WriteLine(Math.Pow(2, 3));

3. Math.Powの戻り値はdouble型

3-1. Math.Powの戻り値がdoubleになる理由

Math.Powの引数と戻り値は、いずれもdouble型です。

public static double Pow(double x, double y);

累乗の結果は必ずしも整数になるとは限りません。たとえば、負の指数や小数の指数を使用すると、小数の結果が返されます。

Console.WriteLine(Math.Pow(2, -2));  // 0.25Console.WriteLine(Math.Pow(2, 0.5)); // 約1.414213562...

整数だけでなく幅広い累乗計算に対応するため、Math.Powはdouble型を使用します。

3-2. int型の変数に代入するときの注意点

Math.Powの戻り値はdouble型なので、そのままint型の変数へ代入することはできません。

次のコードはコンパイルエラーになります。

int result = Math.Pow(2, 3);

代表的なエラーメッセージは、「型doubleをintに暗黙的に変換できません」という内容です。

int型で受け取りたい場合は、明示的なキャストが必要です。

int result = (int)Math.Pow(2, 3);Console.WriteLine(result); // 8

ただし、キャストすると小数部分が切り捨てられる点に注意してください。

int result = (int)Math.Pow(2, 0.5);Console.WriteLine(result); // 1

本来の計算結果は約1.414ですが、int型へキャストしたため1になります。

3-3. int・longに変換するキャスト方法

Math.Powの結果をint型へ変換する場合は、次のようにキャストします。

int result = (int)Math.Pow(2, 10);Console.WriteLine(result); // 1024

long型へ変換する場合も同様です。

long result = (long)Math.Pow(2, 40);Console.WriteLine(result); // 1099511627776

値が変換先の範囲内であることを確認したい場合は、checkedを使用できます。

double value = Math.Pow(2, 10);int result = checked((int)value);Console.WriteLine(result);

ただし、整数の累乗を正確に扱う必要がある場合、最初からdouble型を経由するMath.Powが適切とは限りません。特に大きな整数では丸め誤差が起こるため、整数型だけで計算する自作関数も検討しましょう。

3-4. 小数誤差が起きるケース

double型は浮動小数点数であり、多くの値を2進数の有限桁で近似して保存します。そのため、計算によってはわずかな誤差が含まれます。

double result = Math.Pow(0.1, 2);Console.WriteLine(result);

数学上の結果は0.01ですが、内部的には非常に近い別の値として保持されることがあります。

小数を比較するときは、==で完全一致を確認するのではなく、許容誤差を使う方法があります。

double actual = Math.Pow(0.1, 2);double expected = 0.01;double tolerance = 1e-12;
bool isEqual = Math.Abs(actual - expected) < tolerance;Console.WriteLine(isEqual);

表示上の不要な桁を抑えたいだけであれば、書式指定やMath.Roundも利用できます。

double result = Math.Pow(0.1, 2);Console.WriteLine($"{result:F2}");       // 0.01Console.WriteLine(Math.Round(result, 2)); // 0.01

3-5. 整数の累乗結果を扱うときの安全な考え方

整数の累乗を扱う場合は、目的に応じて方法を選ぶことが重要です。

結果の表示や一般的な数学計算であれば、Math.Powを使う方法が簡単です。

double result = Math.Pow(2, 10);

一方、次の条件に該当する場合は、整数型による自前計算が適しています。

計算結果を整数として正確に扱いたい
大きな整数を扱いたい
オーバーフローを検出したい
浮動小数点数の丸め誤差を避けたい

整数の乗算でオーバーフローを検出する例は次のとおりです。

static long PowInteger(long baseValue, int exponent){if (exponent < 0){throw new ArgumentOutOfRangeException(nameof(exponent),"指数には0以上の整数を指定してください。");}
long result = 1;checked{for (int i = 0; i &lt; exponent; i++){result *= baseValue;}}return result;}

4. C#の「^」演算子は累乗ではない

4-1. ^演算子は累乗ではなく排他的論理和

C#の^演算子は、整数に対して使用した場合、ビット単位の排他的論理和、つまりXORを計算します。

排他的論理和では、2つのビットが異なる場合に1、同じ場合に0となります。

0 ^ 0 = 00 ^ 1 = 11 ^ 0 = 11 ^ 1 = 0

たとえば、2と3を2進数で表すと次のようになります。

2 = 00103 = 0011

各ビットに対して排他的論理和を計算すると、結果は1です。

00100011

0001

したがって、次のコードは1を出力します。

Console.WriteLine(2 ^ 3); // 1

4-2. 2 ^ 3 が8にならない理由

数学では、2の3乗は8です。

2³ = 8

しかし、C#の2 ^ 3は累乗ではなくXORとして評価されます。

int result = 2 ^ 3;Console.WriteLine(result); // 1

2の3乗を計算したい場合は、Math.Powを使用します。

double result = Math.Pow(2, 3);Console.WriteLine(result); // 8

4-3. C言語・JavaScript・VB.NETなどとの違い

累乗を表す記号は、プログラミング言語によって異なります。

C言語の^も、C#と同様にビット単位のXORです。C言語で累乗を計算するときは、標準数学ライブラリのpow関数などを使用します。

JavaScriptでも^はビット単位のXORです。累乗には**演算子やMath.powを使用します。

const result = 2 ** 3;

一方、VB.NETでは^が累乗演算子です。

Dim result = 2 ^ 3

別の言語での経験がある場合、同じ記号でも意味が異なることがあります。C#では「^は累乗ではない」と覚えておきましょう。

4-4. C#で累乗したいときはMath.Powを使う

C#で一般的な累乗を計算する場合は、Math.Powを使用します。

double result = Math.Pow(底, 指数);

例として、7の3乗は次のように計算できます。

double result = Math.Pow(7, 3);Console.WriteLine(result); // 343

2乗や3乗など回数が少ない場合は、掛け算で書くことも可能です。

int x = 7;int square = x * x;int cube = x * x * x;

4-5. 初心者が間違えやすい書き方と修正例

間違いやすい例は次のコードです。

int result = 5 ^ 2;

このコードでは、5の2乗ではなく5と2のXORが計算されます。

正しくは次のように記述します。

double result = Math.Pow(5, 2);Console.WriteLine(result); // 25

整数として受け取りたい場合はキャストできます。

int result = (int)Math.Pow(5, 2);Console.WriteLine(result); // 25

2乗だけであれば、掛け算のほうが型変換を必要とせず、簡潔です。

int x = 5;int result = x * x;Console.WriteLine(result); // 25

5. よく使う累乗計算のサンプル

5-1. 2乗を計算する方法

Math.Powを使って2乗を計算する場合は、指数に2を指定します。

double result = Math.Pow(6, 2);Console.WriteLine(result); // 36

変数の値を2乗する場合は次のように記述します。

double x = 4.5;double result = Math.Pow(x, 2);Console.WriteLine(result); // 20.25

整数の2乗であれば、x * xでも計算できます。

int x = 6;int result = x * x;Console.WriteLine(result); // 36

5-2. 3乗を計算する方法

3乗を計算する場合は、指数に3を指定します。

double result = Math.Pow(4, 3);Console.WriteLine(result); // 64

掛け算で記述する場合は次のとおりです。

int x = 4;int result = x * x * x;Console.WriteLine(result); // 64

5-3. n乗を計算する方法

指数が変数で決まる場合も、Math.Powを使用できます。

double baseValue = 3;double exponent = 5;
double result = Math.Pow(baseValue, exponent);Console.WriteLine(result); // 243

ユーザーから底と指数を入力してもらう例は次のとおりです。

using System;
class Program{static void Main(){Console.Write("底を入力してください：");double baseValue = double.Parse(Console.ReadLine()!);
    Console.Write("指数を入力してください：");double exponent = double.Parse(Console.ReadLine()!);double result = Math.Pow(baseValue, exponent);Console.WriteLine($"{baseValue}の{exponent}乗は{result}です");}}

入力値を安全に処理したい場合は、double.TryParseを使用します。

Console.Write("底を入力してください：");bool baseSuccess = double.TryParse(Console.ReadLine(), out double baseValue);
Console.Write("指数を入力してください：");bool exponentSuccess = double.TryParse(Console.ReadLine(), out double exponent);if (baseSuccess && exponentSuccess){Console.WriteLine(Math.Pow(baseValue, exponent));}else{Console.WriteLine("数値を正しく入力してください。");}

5-4. 2の累乗を計算する方法

2のn乗を計算する場合は、底に2を指定します。

int exponent = 10;double result = Math.Pow(2, exponent);Console.WriteLine(result); // 1024

指数が小さな非負整数であり、整数の結果が必要な場合は、ビットシフトを使えるケースもあります。

int exponent = 10;int result = 1 << exponent;Console.WriteLine(result); // 1024

ただし、ビットシフトは整数型のビット幅やシフト回数に注意が必要です。また、負の指数や小数の指数には使用できません。一般的な数学計算ではMath.Powを使うほうが分かりやすいでしょう。

5-5. ループで複数の累乗を出力する方法

2の0乗から2の10乗までを表示する例です。

for (int exponent = 0; exponent <= 10; exponent++){double result = Math.Pow(2, exponent);
Console.WriteLine($"2の{exponent}乗 = {result}");}

実行結果は次のようになります。

2の0乗 = 12の1乗 = 22の2乗 = 42の3乗 = 82の4乗 = 162の5乗 = 322の6乗 = 642の7乗 = 1282の8乗 = 2562の9乗 = 5122の10乗 = 1024

複数の底について2乗を表示することもできます。

for (int x = 1; x <= 10; x++){Console.WriteLine($"{x}の2乗 = {Math.Pow(x, 2)}");}

5-6. 平方根・ルートを計算する方法

平方根は、指数に0.5を指定することで計算できます。

double result = Math.Pow(9, 0.5);Console.WriteLine(result); // 3

ただし、平方根を求める目的であれば、Math.Sqrtを使うほうが意図が明確です。

double result = Math.Sqrt(9);Console.WriteLine(result); // 3

立方根は指数に1.0 / 3.0を指定して計算できます。

double result = Math.Pow(27, 1.0 / 3.0);Console.WriteLine(result); // 3に近い値

1 / 3と書くと整数同士の除算になり、結果が0になるため注意してください。

// 1 / 3は整数除算なので0double wrong = Math.Pow(27, 1 / 3);Console.WriteLine(wrong); // 1

少なくとも一方を小数にします。

double result = Math.Pow(27, 1.0 / 3.0);

立方根にはMath.Cbrtを使用できる環境もあります。

double result = Math.Cbrt(27);Console.WriteLine(result); // 3

6. Math.Powを使わない累乗計算の方法

6-1. 2乗なら x * x で計算できる

2乗だけを計算する場合は、Math.Powを使わずにx * xと書けます。

int x = 8;int result = x * x;Console.WriteLine(result); // 64

この方法には、次の利点があります。

コードが単純
戻り値がdoubleにならない
整数型のまま計算できる
累乗の回数が明確

double型の値にも使用できます。

double x = 1.5;double result = x * x;Console.WriteLine(result); // 2.25

6-2. 3乗なら x * x * x で計算できる

3乗の場合は、同じ値を3回掛けます。

int x = 5;int result = x * x * x;Console.WriteLine(result); // 125

2乗や3乗のように指数が固定されている場合、直接掛け算したほうが読みやすいことがあります。

一方、指数が変数で決まる場合は、掛け算を直接並べることができないため、Math.Powやループ処理を使用します。

6-3. 整数の累乗をfor文で計算する

0以上の整数指数だけを扱うのであれば、for文で累乗を計算できます。

static long Pow(long baseValue, int exponent){if (exponent < 0){throw new ArgumentOutOfRangeException(nameof(exponent),"指数には0以上の整数を指定してください。");}
long result = 1;for (int i = 0; i &lt; exponent; i++){result *= baseValue;}return result;}

呼び出し例は次のとおりです。

long result = Pow(2, 10);Console.WriteLine(result); // 1024

指数が0の場合は、ループが一度も実行されず1が返ります。

Console.WriteLine(Pow(5, 0)); // 1

オーバーフローを検出する場合は、乗算をcheckedブロック内で行います。

checked{result *= baseValue;}

6-4. 再帰処理で累乗を計算する

累乗は再帰処理でも実装できます。

static long PowRecursive(long baseValue, int exponent){if (exponent < 0){throw new ArgumentOutOfRangeException(nameof(exponent),"指数には0以上の整数を指定してください。");}
if (exponent == 0){return 1;}return checked(baseValue * PowRecursive(baseValue, exponent - 1));}

使用例は次のとおりです。

long result = PowRecursive(3, 4);Console.WriteLine(result); // 81

再帰処理は累乗の定義をそのまま表現できますが、指数が大きいと呼び出し回数が増えます。実用上は、単純なループや繰り返し二乗法のほうが扱いやすいことが多いでしょう。

6-5. 繰り返し二乗法で効率よく計算する

繰り返し二乗法は、指数を2進数として考え、必要な乗算回数を減らす方法です。「二分累乗法」や「高速累乗法」と呼ばれることもあります。

単純なループでは、指数が1000なら最大1000回の乗算を行います。一方、繰り返し二乗法では、指数を半分ずつ処理できます。

static long PowFast(long baseValue, int exponent){if (exponent < 0){throw new ArgumentOutOfRangeException(nameof(exponent),"指数には0以上の整数を指定してください。");}
long result = 1;long current = baseValue;int remaining = exponent;checked{while (remaining &gt; 0){if ((remaining &amp; 1) == 1){result *= current;}remaining &gt;&gt;= 1;if (remaining &gt; 0){current *= current;}}}return result;}

使用例は次のとおりです。

Console.WriteLine(PowFast(2, 10)); // 1024Console.WriteLine(PowFast(3, 5));  // 243Console.WriteLine(PowFast(7, 0));  // 1

指数が大きい整数の累乗を自前で計算するときに有効です。ただし、結果がlong型の範囲を超えるとオーバーフローするため、必要に応じてBigIntegerの使用も検討します。

7. Math.Powを使うときの注意点

7-1. 負の指数を指定した場合

指数が負の場合、逆数が計算されます。

2⁻³ = 1 ÷ 2³ = 1 ÷ 8 = 0.125

C#では次のように計算できます。

double result = Math.Pow(2, -3);Console.WriteLine(result); // 0.125

負の指数を指定すると小数になる可能性が高いため、int型へキャストすると情報が失われます。

int result = (int)Math.Pow(2, -3);Console.WriteLine(result); // 0

7-2. 小数の指数を指定した場合

Math.Powでは小数の指数も指定できます。

指数が0.5の場合は平方根に相当します。

double result = Math.Pow(16, 0.5);Console.WriteLine(result); // 4

指数が1.5の場合は、次のような計算に相当します。

x¹·⁵ = x × √x

double result = Math.Pow(4, 1.5);Console.WriteLine(result); // 8

7-3. 負の数に小数の指数を指定した場合

負の数に整数の指数を指定することは可能です。

Console.WriteLine(Math.Pow(-2, 2)); // 4Console.WriteLine(Math.Pow(-2, 3)); // -8

一方、負の数に一般的な小数の指数を指定すると、実数の範囲で結果を表せないことがあります。その場合、Math.PowはNaNを返します。

double result = Math.Pow(-2, 0.5);Console.WriteLine(result);              // NaNConsole.WriteLine(double.IsNaN(result)); // True

これは、実数の範囲ではマイナス2の平方根を表せないためです。複素数として計算する必要がある場合は、System.Numerics.Complexを使用します。

7-4. 計算結果が大きすぎる場合

累乗では値が急速に大きくなります。

double result = Math.Pow(10, 100);

double型で表現できる上限を超えると、結果は正または負の無限大になります。

double result = Math.Pow(10, 1000);Console.WriteLine(result);                    // InfinityConsole.WriteLine(double.IsInfinity(result)); // True

整数型へ変換する場合は、intやlongの範囲も考慮しなければなりません。

int  ：約-21億～約21億long ：約-922京～約922京

非常に大きな整数を正確に扱う場合は、System.Numerics.BigIntegerを使用できます。

using System.Numerics;
BigInteger result = BigInteger.Pow(10, 100);Console.WriteLine(result);

BigInteger.Powの指数は0以上のint型であり、負の指数や小数の指数には対応していません。

7-5. NaNやInfinityになるケース

Math.Powの結果として、通常の数値以外にNaNやInfinityが返ることがあります。

NaNは「数値ではない」ことを表します。

double result = Math.Pow(-1, 0.5);if (double.IsNaN(result)){Console.WriteLine("実数として計算できません。");}

Infinityは無限大を表します。

double result = Math.Pow(10, 1000);if (double.IsInfinity(result)){Console.WriteLine("計算結果が大きすぎます。");}

有限の数値であることを確認するには、double.IsFiniteも利用できます。

double result = Math.Pow(10, 100);if (double.IsFinite(result)){Console.WriteLine(result);}else{Console.WriteLine("有限の数値ではありません。");}

7-6. パフォーマンスを重視する場合の使い分け

一般的なプログラムでは、まず可読性を優先してMath.Powを使用して問題ありません。

double result = Math.Pow(x, exponent);

ただし、同じ処理を大量に繰り返す場合や、指数が2または3に固定されている場合は、直接掛け算する方法が適していることがあります。

double square = x * x;double cube = x * x * x;

0以上の整数指数を整数型だけで計算したい場合は、繰り返し二乗法も選択肢です。

実際の性能差は、実行環境、データ型、指数、呼び出し回数などで変わります。性能が重要な処理では、推測だけで決めず、ベンチマークを取って比較しましょう。

8. C#の累乗計算でよくあるエラーと対処法

8-1. ^を使って期待通りの結果にならない

次のコードで8を期待しても、結果は1になります。

int result = 2 ^ 3;Console.WriteLine(result); // 1

原因は、C#の^が累乗ではなくXORを表すためです。

Math.Powに修正します。

double result = Math.Pow(2, 3);Console.WriteLine(result); // 8

2乗や3乗であれば、掛け算でも構いません。

int square = 2 * 2;int cube = 2 * 2 * 2;

8-2. doubleからintへ暗黙的に変換できない

次のコードはコンパイルエラーになります。

int result = Math.Pow(2, 3);

Math.Powの戻り値がdouble型だからです。

double型で受け取る場合は次のようにします。

double result = Math.Pow(2, 3);

int型が必要で、結果が範囲内の整数になることを確認できる場合は、明示的にキャストします。

int result = checked((int)Math.Pow(2, 3));

ただし、キャストでは小数部分が切り捨てられます。

8-3. Math.Powの結果に小数点が付く

Math.Powはdouble型を返します。出力方法や環境によっては、整数相当の結果でも小数形式で表示されることがあります。

表示形式を整数にしたいだけであれば、書式を指定できます。

double result = Math.Pow(2, 3);Console.WriteLine($"{result:F0}"); // 8

文字列として小数点以下を表示しない場合は、F0などの数値書式を使用します。

値そのものを整数型へ変換したい場合はキャストできますが、範囲や小数部分に注意が必要です。

int result = checked((int)Math.Pow(2, 3));

8-4. 小数誤差で結果がずれる

浮動小数点数の計算では、期待値とわずかに異なることがあります。

double result = Math.Pow(0.1, 2);double expected = 0.01;

このような値を比較するときは、許容誤差を使います。

double tolerance = 1e-12;if (Math.Abs(result - expected) < tolerance){Console.WriteLine("ほぼ等しい値です。");}

金額など10進数としての正確さが重要な値ではdecimal型が候補になります。ただし、Math.Powはdecimal型を直接受け取らないため、整数指数ならdecimal同士の乗算で自前計算する方法があります。

static decimal PowDecimal(decimal baseValue, int exponent){if (exponent < 0){throw new ArgumentOutOfRangeException(nameof(exponent));}
decimal result = 1m;checked{for (int i = 0; i &lt; exponent; i++){result *= baseValue;}}return result;}

8-5. オーバーフローや桁あふれが起きる

整数型で累乗を計算すると、結果が型の範囲を超えることがあります。

int x = 50_000;int result = x * x;

オーバーフローを検出したい場合はcheckedを使用します。

try{int x = 50_000;int result = checked(x * x);
Console.WriteLine(result);}catch (OverflowException){Console.WriteLine("int型の範囲を超えました。");}

より大きな範囲が必要ならlong型を使用します。

long x = 50_000;long result = checked(x * x);Console.WriteLine(result); // 2500000000

long型でも不足する場合はBigIntegerが候補です。

using System.Numerics;
BigInteger result = BigInteger.Pow(50_000, 10);Console.WriteLine(result);

9. Math.Powと自前計算の使い分け

9-1. 基本はMath.Powを使う

一般的な累乗計算では、Math.Powを使うのが簡単です。

double result = Math.Pow(baseValue, exponent);

Math.Powには次の特徴があります。

標準ライブラリだけで使用できる
負の指数を扱える
小数の指数を扱える
コードから累乗であることが分かりやすい

指数が実行時に変化する場合や、整数以外の指数を扱う場合は、まずMath.Powを検討しましょう。

9-2. 2乗・3乗だけなら掛け算のほうがシンプル

指数が2または3に固定されているなら、直接掛け算する方法がシンプルです。

double square = x * x;double cube = x * x * x;

戻り値を整数型のまま扱いたい場合にも便利です。

int x = 10;int square = x * x;

ただし、計算結果が型の範囲を超える可能性がある場合は、checkedを使用します。

int square = checked(x * x);

9-3. 整数だけを扱うなら自作関数も選択肢

底と指数が整数で、結果も整数として正確に扱いたい場合は、自作関数が選択肢になります。

static long PowInteger(long baseValue, int exponent){if (exponent < 0){throw new ArgumentOutOfRangeException(nameof(exponent));}
long result = 1;checked{for (int i = 0; i &lt; exponent; i++){result *= baseValue;}}return result;}

この方法では、double型を経由しないため、浮動小数点数への変換による丸めを避けられます。

ただし、負の指数や小数の指数には対応していません。

9-4. 高速化したい場合は繰り返し二乗法を検討する

整数指数が大きい場合は、繰り返し二乗法で乗算回数を減らせます。

単純なループの計算量は指数をnとすると、おおむねO(n)です。繰り返し二乗法では、おおむねO(log n)の乗算回数で計算できます。

暗号、競技プログラミング、剰余累乗などでは、繰り返し二乗法がよく使われます。

ただし、一般的な業務プログラムで指数が小さい場合は、複雑な自作処理を追加するより、Math.Powや単純な掛け算のほうが読みやすいことがあります。

9-5. 可読性と正確性を優先した選び方

C#で累乗を計算する方法は、次の基準で選ぶと分かりやすくなります。

条件	適した方法
一般的な累乗計算	`Math.Pow`
負の指数や小数の指数	`Math.Pow`
2乗	`x * x`
3乗	`x * x * x`
0以上の整数指数を整数型で計算	自作関数
非常に大きな整数	`BigInteger.Pow`
大きな整数指数を効率よく計算	繰り返し二乗法
平方根	`Math.Sqrt`
立方根	`Math.Cbrt`

単純に短いコードを選ぶだけでなく、必要な数値の範囲、誤差、オーバーフロー、読みやすさを考慮することが大切です。

10. C#の累乗に関するよくある質問

10-1. C#に累乗演算子はありますか？

C#には累乗専用の演算子はありません。

一般的な累乗計算にはMath.Powを使用します。

double result = Math.Pow(2, 3);

**はC#の累乗演算子として使用できません。また、^は累乗ではなくXORです。

10-2. Math.Powの戻り値はなぜdoubleですか？

負の指数や小数の指数など、結果が整数にならない累乗も扱うためです。

Console.WriteLine(Math.Pow(2, -1));  // 0.5Console.WriteLine(Math.Pow(2, 0.5)); // 約1.414

そのため、底と指数に整数を渡した場合でも、戻り値はdouble型です。

double result = Math.Pow(2, 3);

10-3. Math.Powの結果をintで受け取れますか？

明示的にキャストすれば、int型で受け取れます。

int result = (int)Math.Pow(2, 3);

ただし、小数部分は切り捨てられます。また、値がint型の範囲を超える可能性もあります。

安全性を高める場合は、値が整数で範囲内か確認してから変換します。

double value = Math.Pow(2, 10);if (double.IsFinite(value) &&value == Math.Truncate(value) &&value >= int.MinValue &&value <= int.MaxValue){int result = (int)value;Console.WriteLine(result);}else{Console.WriteLine("int型へ安全に変換できません。");}

整数の累乗を正確に計算したい場合は、整数型だけを使う自作関数も検討してください。

10-4. 2乗だけならMath.Powと掛け算のどちらがよいですか？

2乗だけなら、通常はx * xがシンプルです。

double result = x * x;

計算が累乗であることを統一的に表現したい場合や、指数を後から変更する可能性がある場合は、Math.Powでも問題ありません。

double result = Math.Pow(x, 2);

整数型の値を整数型のまま計算したい場合は、x * xが扱いやすいでしょう。

10-5. ^演算子は何に使うものですか？

整数に対する^演算子は、ビット単位の排他的論理和を計算するために使用します。

int result = 5 ^ 3;Console.WriteLine(result); // 6

2進数では次の計算になります。

5 = 01013 = 00110110 = 6</span></code></pre><p><span>また、</span><code dir="ltr"><span>bool</span></code><span>型に対しては論理排他的ORとして使用できます。</span></p><pre dir="ltr"><code dir="ltr"><span>Console.WriteLine(true ^ false); // TrueConsole.WriteLine(true ^ true);  // False

どちらの場合も累乗ではありません。

まとめ

C#で累乗を計算する基本的な方法は、Math.Powを使用することです。

double result = Math.Pow(2, 3);Console.WriteLine(result); // 8

Math.Powの第1引数には底、第2引数には指数を指定します。戻り値は常にdouble型なので、int型やlong型へ代入するときは明示的な変換が必要です。

int result = checked((int)Math.Pow(2, 3));

ただし、キャストでは小数部分が切り捨てられ、大きな整数では浮動小数点数の丸め誤差が生じる可能性があります。整数として正確に計算したい場合は、整数型による自作関数やBigInteger.Powを検討しましょう。

また、C#の^演算子は累乗ではなく、排他的論理和を表します。

Console.WriteLine(2 ^ 3);         // 1Console.WriteLine(Math.Pow(2, 3)); // 8

用途ごとの基本的な選び方は次のとおりです。

一般的な累乗はMath.Pow
2乗はx * x
3乗はx * x * x
平方根はMath.Sqrt
整数の累乗を正確に扱うなら整数型の自作関数
非常に大きな整数にはBigInteger.Pow
大きな整数指数を効率よく処理するなら繰り返し二乗法

戻り値の型、浮動小数点数の誤差、オーバーフローに注意しながら、目的に合った計算方法を選びましょう。