C#で累乗を計算する方法｜Math.Powの使い方とint・double変換の注意点

はじめに

C#で「累乗」や「べき乗」を計算したいとき、まず思い浮かぶのが「2の3乗」「10の2乗」のような計算です。

たとえば、2の3乗は次のような意味になります。

C#
2 × 2 × 2 = 8

C#で累乗を計算する場合は、基本的に Math.Pow メソッドを使います。

ただし、C#には他の言語にあるような累乗演算子がなく、^ を使っても累乗にはなりません。また、Math.Pow の戻り値は int ではなく double になるため、整数として扱いたい場合には型変換にも注意が必要です。

この記事では、C#で累乗を計算する方法を、Math.Pow の基本から int・double・float への変換、よくあるエラー、実用例までわかりやすく解説します。

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

1-1. C#には累乗演算子がない

C#には、累乗専用の演算子は用意されていません。

たとえば、Pythonでは次のように ** を使って累乗を計算できます。

Python
実行する
2 ** 3

しかし、C#では次のような書き方はできません。

C#
int result = 2 ** 3; // C#ではエラー

また、C#で ^ を使って次のように書いても、累乗にはなりません。

C#
int result = 2 ^ 3;

このコードは「2の3乗」ではなく、ビット演算のXORを意味します。そのため、累乗計算をしたい場合は別の方法を使う必要があります。

1-2. 累乗計算にはMath.Powを使う

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

C#
double result = Math.Pow(2, 3);
Console.WriteLine(result);

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

C#
8

Math.Pow(2, 3) は、「2を3乗する」という意味です。

つまり、次の計算と同じです。

C#
2 * 2 * 2

Math.Pow は、整数だけでなく小数や負の指数も扱えるため、C#で累乗計算をするときによく使われます。

1-3. 「csharp power」で検索する人が知りたいこと

「csharp power」や「C# power」と検索する人の多くは、C#でべき乗をどう書けばよいのかを知りたいはずです。

C#では、英語の「power」は累乗やべき乗を意味する文脈でよく使われます。たとえば「2 to the power of 3」は「2の3乗」という意味です。

C#でこの計算を行う場合は、次のように書きます。

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

つまり、「csharp power」で知っておくべき基本は次の3つです。

C#
// C#に累乗演算子はない
// 累乗にはMath.Powを使う
// Math.Powの戻り値はdoubleになる

この3点を理解しておくと、C#での累乗計算につまずきにくくなります。

2. Math.Powの基本的な使い方

2-1. Math.Powの構文

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

C#
Math.Pow(底, 指数)

実際のコードでは次のように書きます。

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

この場合、2 が底、3 が指数です。

計算結果は 2 の 3 乗なので、8 になります。

2-2. 第1引数と第2引数の意味

Math.Pow には2つの引数を指定します。

C#
Math.Pow(x, y)

このとき、x は底、y は指数を表します。

たとえば、次のコードを見てみましょう。

C#
double result = Math.Pow(5, 2);
Console.WriteLine(result);

これは「5の2乗」を計算しています。

C#
5 * 5 = 25

そのため、実行結果は次のようになります。

C#
25

第1引数と第2引数を逆にすると、計算結果も変わります。

C#
Console.WriteLine(Math.Pow(2, 5)); // 32
Console.WriteLine(Math.Pow(5, 2)); // 25

Math.Pow(2, 5) は2の5乗、Math.Pow(5, 2) は5の2乗です。

2-3. 2の3乗を計算するサンプルコード

C#で2の3乗を計算する基本的なサンプルは次のとおりです。

C#
using System;

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

        Console.WriteLine(result);
    }
}

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

C#
8

Math.Pow は System 名前空間に含まれる Math クラスのメソッドです。

最近のC#プロジェクトでは using System; が自動で使える場合もありますが、基本的なコンソールアプリでは次のように書いておくとわかりやすいです。

C#
using System;

2-4. 小数や負の指数を使う場合の例

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

たとえば、0.5乗は平方根と同じ意味になります。

C#
double result = Math.Pow(9, 0.5);
Console.WriteLine(result);

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

C#
3

また、負の指数を指定することもできます。

C#
double result = Math.Pow(2, -3);
Console.WriteLine(result);

これは次のような計算です。

C#
1 / (2 * 2 * 2)

そのため、実行結果は次のようになります。

C#
0.125

このように、Math.Pow は整数の累乗だけでなく、小数や逆数を含む計算にも使えます。

3. Math.Powの戻り値はdoubleになる

3-1. Math.Powはintではなくdoubleを返す

Math.Pow を使うときに最も注意したいのは、戻り値が double 型になることです。

たとえば、次のコードは問題なく動作します。

C#
double result = Math.Pow(2, 3);
Console.WriteLine(result);

しかし、次のように int 型の変数に直接代入しようとするとエラーになります。

C#
int result = Math.Pow(2, 3); // エラー

Math.Pow(2, 3) の計算結果は見た目には 8 ですが、型としては double です。

そのため、int 型に入れるには明示的な変換が必要です。

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

Math.Pow の結果を int 型で受け取りたい場合、次のように直接代入することはできません。

C#
int result = Math.Pow(10, 2); // エラー

C#では、double から int への変換は暗黙的には行われません。

なぜなら、double には小数点以下の値が含まれる可能性があるからです。

たとえば、次のような結果になるケースがあります。

C#
double result = Math.Pow(2, -1);
Console.WriteLine(result); // 0.5

このような値を int に変換すると、小数点以下をどう扱うかが問題になります。

そのため、C#では開発者が明示的に変換方法を指定する必要があります。

3-3. キャストしてintに変換する方法

Math.Pow の結果を int に変換するには、明示的なキャストを使います。

C#
int result = (int)Math.Pow(2, 3);
Console.WriteLine(result);

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

C#
8

このように、(int) を付けることで double 型の結果を int 型に変換できます。

ただし、キャストを使う場合は、小数点以下が切り捨てられる点に注意が必要です。

3-4. 小数点以下が切り捨てられるケース

(int) でキャストすると、小数点以下は切り捨てられます。

たとえば、次のコードを見てみましょう。

C#
double value = Math.Pow(2, -1);
int result = (int)value;

Console.WriteLine(value);
Console.WriteLine(result);

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

C#
0.5
0

Math.Pow(2, -1) の結果は 0.5 ですが、int にキャストすると 0 になります。

また、次のような場合も小数点以下が切り捨てられます。

C#
double value = 3.9;
int result = (int)value;

Console.WriteLine(result);

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

C#
3

四捨五入ではない点に注意してください。

四捨五入したい場合は、Math.Round などを使う必要があります。

C#
double value = 3.9;
int result = (int)Math.Round(value);

Console.WriteLine(result); // 4

4. int型で累乗計算したい場合の書き方

4-1. Math.Powの結果をintに変換する例

整数の累乗計算をして、その結果も int 型で扱いたい場合は、次のように書きます。

C#
int result = (int)Math.Pow(3, 4);

Console.WriteLine(result);

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

C#
81

3 の 4 乗は次の計算です。

C#
3 * 3 * 3 * 3 = 81

ただし、Math.Pow は常に double を返すため、int として扱いたい場合は毎回変換が必要です。

C#
double powResult = Math.Pow(3, 4);
int intResult = (int)powResult;

このように一度 double で受け取ってから int に変換すると、型の流れがわかりやすくなります。

4-2. Convert.ToInt32を使う方法

int に変換する方法として、Convert.ToInt32 を使うこともできます。

C#
int result = Convert.ToInt32(Math.Pow(2, 3));

Console.WriteLine(result);

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

C#
8

ただし、Convert.ToInt32 は単純な切り捨てではありません。

たとえば、次のコードを見てみましょう。

C#
Console.WriteLine((int)3.9);
Console.WriteLine(Convert.ToInt32(3.9));

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

C#
3
4

(int) によるキャストは小数点以下を切り捨てますが、Convert.ToInt32 は丸め処理を行います。

そのため、整数の累乗結果が確実に小数にならない場合はどちらでも使えますが、小数が絡む場合は結果が変わる可能性があります。

4-3. オーバーフローに注意する

累乗計算では、値が急激に大きくなります。

たとえば、2の10乗は1024ですが、2の30乗はかなり大きな値になります。

C#
Console.WriteLine(Math.Pow(2, 10)); // 1024
Console.WriteLine(Math.Pow(2, 30)); // 1073741824

int 型で扱える範囲を超える値を入れようとすると、オーバーフローに注意が必要です。

int の最大値は次の値です。

C#
Console.WriteLine(int.MaxValue);

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

C#
2147483647

たとえば、2の31乗は int の最大値を超えます。

C#
double value = Math.Pow(2, 31);
Console.WriteLine(value);

この値を無理に int に変換しようとすると、正しく扱えない可能性があります。

安全に扱いたい場合は、checked を使ってオーバーフローを検出する方法があります。

C#
try
{
    int result = checked((int)Math.Pow(2, 31));
    Console.WriteLine(result);
}
catch (OverflowException)
{
    Console.WriteLine("int型の範囲を超えています。");
}

大きな累乗を扱う場合は、int ではなく long、double、decimal、または BigInteger の利用も検討しましょう。

4-4. 整数の累乗計算を自作する方法

指数が整数で、結果も整数として扱いたい場合は、Math.Pow を使わずに自作することもできます。

C#
static int IntPow(int baseValue, int exponent)
{
    int result = 1;

    for (int i = 0; i < exponent; i++)
    {
        result *= baseValue;
    }

    return result;
}

使い方は次のとおりです。

C#
int result = IntPow(2, 3);
Console.WriteLine(result);

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

C#
8

この方法は、指数が0以上の整数である場合にシンプルです。

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

C#
2^-1 = 0.5

このように、負の指数では結果が小数になるため、int だけで正確に表すことはできません。

整数の範囲だけで累乗を扱いたい場合は、自作関数も選択肢になります。

5. double型・float型で累乗計算する場合

5-1. double型で計算する基本例

Math.Pow は戻り値が double なので、double 型で扱う場合はそのまま使えます。

C#
double result = Math.Pow(1.5, 3);

Console.WriteLine(result);

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

C#
3.375

小数を含む累乗計算では、double 型を使うのが自然です。

C#
double baseValue = 2.5;
double exponent = 2;

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

Console.WriteLine(result);

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

C#
6.25

double は小数を扱えるため、科学計算、統計計算、シミュレーション、金利計算などでよく使われます。

5-2. float型で使う場合のキャスト

Math.Pow は double を返すため、float 型の変数に直接代入することはできません。

次のコードはエラーになります。

C#
float result = Math.Pow(2, 3); // エラー

float で受け取りたい場合は、明示的にキャストします。

C#
float result = (float)Math.Pow(2, 3);

Console.WriteLine(result);

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

C#
8

また、引数に float の変数を使うこともできます。

C#
float baseValue = 2.5f;
float exponent = 2.0f;

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

Console.WriteLine(result);

この場合も、Math.Pow の戻り値は double なので、最後に (float) で変換しています。

精度を重視する場合は、float よりも double を使う方が一般的です。

5-3. 小数の累乗計算で誤差が出る理由

double や float は、小数を2進数で表現します。

そのため、10進数ではきれいに表せる小数でも、コンピューター内部では正確に表せないことがあります。

たとえば、次のような計算では、期待した値とわずかに異なる結果になる場合があります。

C#
double result = Math.Pow(0.1, 2);

Console.WriteLine(result);

数学的には 0.01 ですが、内部表現の都合により、表示や計算の過程でわずかな誤差が出ることがあります。

これは Math.Pow の問題というより、浮動小数点数の性質です。

特に次のようなケースでは注意が必要です。

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 epsilon = 0.0000001;

Console.WriteLine(Math.Abs(a - b) < epsilon);

5-4. 計算結果を丸める方法

小数の累乗計算で表示桁数を整えたい場合は、Math.Round を使います。

C#
double result = Math.Pow(1.2345, 2);

double rounded = Math.Round(result, 2);

Console.WriteLine(rounded);

このコードでは、小数第2位までに丸めています。

また、文字列として表示するときだけ桁数を指定することもできます。

C#
double result = Math.Pow(1.2345, 2);

Console.WriteLine(result.ToString("F2"));

F2 は小数第2位まで表示する指定です。

計算そのものを丸めたい場合は Math.Round、表示だけ整えたい場合は ToString の書式指定を使うとよいでしょう。

6. よくあるエラーと注意点

6-1. Math.Powの結果をintに直接代入できない

C#で累乗計算をするときによくあるエラーが、Math.Pow の結果を int に直接代入してしまうことです。

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

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

理由は、Math.Pow の戻り値が double だからです。

正しくは次のように書きます。

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

または、double 型で受け取ります。

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

整数として扱う必要がない場合は、無理に int に変換せず、double のまま扱う方が安全です。

6-2. ^は累乗ではなくXOR演算子

C#では、^ は累乗演算子ではありません。

次のコードを見てみましょう。

C#
int result = 2 ^ 3;

Console.WriteLine(result);

「2の3乗だから8になる」と思うかもしれませんが、実際には違います。

^ はビットごとのXOR演算子です。

2と3を2進数で考えると、次のようになります。

C#
2 = 10
3 = 11

XORでは、ビットが異なるところだけが1になります。

C#
10
11
--
01

そのため、結果は 1 になります。

C#
1

累乗を計算したい場合は、次のように Math.Pow を使います。

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

C#で「power」を計算したいときに ^ を使わないように注意しましょう。

6-3. 負の数や0を使う場合の挙動

Math.Pow は負の数や0も扱えますが、組み合わせによって結果が変わります。

負の数を整数乗する場合は、通常どおり計算できます。

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

負の数を奇数乗すると負の値になり、偶数乗すると正の値になります。

一方で、負の数に小数の指数を指定すると、実数として表せない場合があります。

C#
Console.WriteLine(Math.Pow(-2, 0.5));

このような計算では、結果が NaN になることがあります。

NaN は「Not a Number」の意味です。

また、0乗については、次のようになります。

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

多くのプログラミング言語と同様に、Math.Pow(0, 0) は 1 を返します。

0に負の指数を指定する場合は、無限大になる可能性があります。

C#
Console.WriteLine(Math.Pow(0, -1));

このように、負の数や0を扱う場合は、結果が NaN や Infinity になるケースにも注意しましょう。

6-4. 大きな累乗で値が大きくなりすぎる問題

累乗計算では、指数が少し増えるだけで結果が急激に大きくなります。

C#
Console.WriteLine(Math.Pow(10, 3));  // 1000
Console.WriteLine(Math.Pow(10, 6));  // 1000000
Console.WriteLine(Math.Pow(10, 12)); // 1000000000000

double 型は非常に大きな値を扱えますが、それでも限界があります。

極端に大きい累乗では、結果が Infinity になることがあります。

C#
double result = Math.Pow(10, 1000);

Console.WriteLine(result);

このような計算では、通常の数値型では扱いきれない場合があります。

整数の巨大な累乗を正確に扱いたい場合は、System.Numerics.BigInteger を使う方法があります。

C#
using System;
using System.Numerics;

class Program
{
    static void Main()
    {
        BigInteger result = BigInteger.Pow(10, 50);

        Console.WriteLine(result);
    }
}

BigInteger.Pow は、非常に大きな整数の累乗を扱いたいときに便利です。

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

7-1. 同じ数を掛け算して累乗を計算する

2乗や3乗のような小さな累乗であれば、Math.Pow を使わずに直接掛け算してもかまいません。

C#
int x = 5;

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

Console.WriteLine(square);
Console.WriteLine(cube);

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

C#
25
125

2乗や3乗のように指数が固定されている場合は、直接掛け算した方が読みやすく、型変換の問題も起きにくいです。

C#
int area = width * width;
int volume = length * length * length;

このように、簡単な累乗では掛け算で十分な場合もあります。

7-2. for文で累乗を計算する

指数が変数になる場合は、for 文で繰り返し掛け算する方法があります。

C#
int baseValue = 2;
int exponent = 5;

int result = 1;

for (int i = 0; i < exponent; i++)
{
    result *= baseValue;
}

Console.WriteLine(result);

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

C#
32

この方法では、baseValue を exponent 回掛けています。

関数にすると次のように書けます。

C#
static int PowInt(int baseValue, int exponent)
{
    int result = 1;

    for (int i = 0; i < exponent; i++)
    {
        result *= baseValue;
    }

    return result;
}

使い方は次のとおりです。

C#
int result = PowInt(3, 4);
Console.WriteLine(result);

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

C#
81

ただし、この実装は指数が0以上の整数であることを前提にしています。

7-3. LINQやAggregateを使う方法

LINQの Aggregate を使って累乗を計算することもできます。

C#
using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int baseValue = 2;
        int exponent = 5;

        int result = Enumerable
            .Repeat(baseValue, exponent)
            .Aggregate(1, (acc, x) => acc * x);

        Console.WriteLine(result);
    }
}

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

C#
32

Enumerable.Repeat(baseValue, exponent) で同じ値を指定回数分作り、Aggregate で順番に掛け算しています。

ただし、累乗計算だけを目的にする場合、LINQを使うとやや大げさに見えることもあります。

実務では、単純な累乗なら Math.Pow、整数での繰り返し計算なら for 文の方が読みやすい場合が多いです。

7-4. パフォーマンスを重視する場合の考え方

パフォーマンスを重視する場合は、目的に応じて書き方を選ぶことが大切です。

2乗や3乗のように指数が固定されている場合は、直接掛け算するのがシンプルです。

C#
int square = x * x;
int cube = x * x * x;

小数や負の指数を扱う場合は、Math.Pow を使うのが自然です。

C#
double result = Math.Pow(x, y);

整数の累乗を大量に計算する場合は、for 文や専用の整数累乗関数を用意する方法もあります。

また、大きな指数を効率よく計算したい場合は、繰り返し二乗法を使うこともできます。

C#
static long FastPow(long baseValue, int exponent)
{
    long result = 1;

    while (exponent > 0)
    {
        if ((exponent & 1) == 1)
        {
            result *= baseValue;
        }

        baseValue *= baseValue;
        exponent >>= 1;
    }

    return result;
}

この方法は、単純に何度も掛け算するよりも少ない回数で累乗を計算できます。

ただし、コードは少し複雑になるため、通常は読みやすさを優先し、必要な場面でだけ使うとよいでしょう。

8. C#の累乗計算でよく使う実用例

8-1. 2乗・3乗を計算する

C#でよく使う累乗計算の代表例は、2乗と3乗です。

2乗を計算する場合は、Math.Pow を使う方法と、直接掛け算する方法があります。

C#
double result1 = Math.Pow(5, 2);
int result2 = 5 * 5;

Console.WriteLine(result1);
Console.WriteLine(result2);

どちらも結果は 25 です。

3乗も同じです。

C#
double result1 = Math.Pow(5, 3);
int result2 = 5 * 5 * 5;

Console.WriteLine(result1);
Console.WriteLine(result2);

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

C#
125
125

指数が固定されている場合は、直接掛け算の方が簡単なことも多いです。

8-2. 平方根や指数計算と組み合わせる

Math.Pow は平方根の計算にも使えます。

C#
double result = Math.Pow(9, 0.5);

Console.WriteLine(result);

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

C#
3

ただし、平方根を求める場合は、専用の Math.Sqrt を使う方がわかりやすいです。

C#
double result = Math.Sqrt(9);

Console.WriteLine(result);

また、指数関数を扱う場合は Math.Exp を使うこともあります。

C#
double result = Math.Exp(1);

Console.WriteLine(result);

Math.Pow は任意の底に対する累乗、Math.Sqrt は平方根、Math.Exp は自然指数関数を計算するときに使います。

用途に応じて使い分けましょう。

8-3. 面積・体積計算で使う

累乗は、面積や体積の計算でもよく使われます。

たとえば、正方形の面積は一辺の長さの2乗です。

C#
double side = 5;

double area = Math.Pow(side, 2);

Console.WriteLine(area);

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

C#
25

立方体の体積は、一辺の長さの3乗です。

C#
double side = 5;

double volume = Math.Pow(side, 3);

Console.WriteLine(volume);

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

C#
125

ただし、2乗や3乗であれば直接掛け算してもわかりやすいです。

C#
double area = side * side;
double volume = side * side * side;

どちらを使うかは、コードの読みやすさや計算内容に応じて選びましょう。

8-4. 金利計算や成長率計算で使う

累乗は、金利計算や成長率計算でもよく使われます。

たとえば、元本に対して毎年一定の利率で増える複利計算は、次のように書けます。

C#
double principal = 100000; // 元本
double rate = 0.05;        // 年利5%
int years = 10;            // 10年

double amount = principal * Math.Pow(1 + rate, years);

Console.WriteLine(amount);

このコードでは、元本10万円を年利5%で10年間運用した場合の金額を計算しています。

成長率の計算でも同じ考え方が使えます。

C#
double initialValue = 100;
double growthRate = 0.1;
int periods = 5;

double futureValue = initialValue * Math.Pow(1 + growthRate, periods);

Console.WriteLine(futureValue);

このように、Math.Pow は単なる数学計算だけでなく、実務的な計算でもよく使われます。

9. C#の累乗計算に関するよくある質問

9-1. C#で2乗を簡単に書く方法は？

C#で2乗を計算する方法は、主に2つあります。

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

または、直接掛け算します。

C#
int result = x * x;

x が int で、結果も整数でよい場合は、x * x の方がシンプルです。

小数を含む計算や、指数を変数として扱いたい場合は Math.Pow を使うとよいでしょう。

9-2. C#でべき乗演算子は使える？

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

次のような書き方はできません。

C#
int result = 2 ** 3; // エラー

また、^ は累乗ではありません。

C#
int result = 2 ^ 3; // 累乗ではなくXOR

C#でべき乗を計算する場合は、基本的に Math.Pow を使います。

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

9-3. Math.Powと^の違いは？

Math.Pow は累乗を計算するメソッドです。

C#
double result = Math.Pow(2, 3); // 8

一方、^ はビットごとのXOR演算子です。

C#
int result = 2 ^ 3; // 1

つまり、Math.Pow(2, 3) は「2の3乗」ですが、2 ^ 3 はビット演算です。

C#で累乗を計算したい場合は、^ ではなく Math.Pow を使いましょう。

9-4. Math.Powの結果をintで受け取るには？

Math.Pow の戻り値は double なので、int で受け取りたい場合は明示的に変換します。

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

または、Convert.ToInt32 を使うこともできます。

C#
int result = Convert.ToInt32(Math.Pow(2, 3));

ただし、(int) は小数点以下を切り捨てます。

C#
int result = (int)3.9; // 3

一方、Convert.ToInt32 は丸め処理を行います。

C#
int result = Convert.ToInt32(3.9); // 4

小数が含まれる可能性がある場合は、どのように整数化したいのかを考えて選びましょう。

9-5. Math.Powで計算結果に誤差が出るのはなぜ？

Math.Pow の結果に誤差が出ることがあるのは、double が浮動小数点数だからです。

コンピューター内部では、小数を2進数で表現します。

そのため、10進数では正確に見える小数でも、内部的には完全に表現できない場合があります。

C#
double result = Math.Pow(0.1, 2);

Console.WriteLine(result);

このような小数計算では、わずかな誤差が発生することがあります。

結果を表示するときは、Math.Round や書式指定を使うと見やすくできます。

C#
double result = Math.Pow(0.1, 2);

Console.WriteLine(Math.Round(result, 2));
Console.WriteLine(result.ToString("F2"));

また、小数同士を比較するときは、== ではなく誤差の範囲を考慮して判定するのが安全です。

C#
double a = Math.Pow(0.1, 2);
double b = 0.01;

double epsilon = 0.0000001;

bool isEqual = Math.Abs(a - b) < epsilon;

Console.WriteLine(isEqual);

まとめ

C#で累乗を計算する場合は、基本的に Math.Pow を使います。

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

このコードは2の3乗を計算し、結果は 8 になります。

ただし、C#には累乗演算子がないため、^ を使ってはいけません。^ は累乗ではなくXOR演算子です。

C#
int result = 2 ^ 3; // これは累乗ではない

また、Math.Pow の戻り値は常に double です。

そのため、int 型で受け取りたい場合は、明示的なキャストや Convert.ToInt32 を使う必要があります。

C#
int result1 = (int)Math.Pow(2, 3);
int result2 = Convert.ToInt32(Math.Pow(2, 3));

ただし、(int) は小数点以下を切り捨て、Convert.ToInt32 は丸め処理を行うため、違いを理解して使い分けることが大切です。

2乗や3乗のような単純な計算であれば、直接掛け算する方法もあります。

C#
int square = x * x;
int cube = x * x * x;

一方、小数の累乗、負の指数、金利計算、成長率計算などでは Math.Pow が便利です。

C#で「power」や累乗計算を扱うときは、次のポイントを押さえておきましょう。

C#
// 累乗にはMath.Powを使う
// ^は累乗ではなくXOR
// Math.Powの戻り値はdouble
// intにする場合は明示的な変換が必要
// 小数計算では誤差に注意する

これらを理解しておけば、C#での累乗計算を安全かつ正しく書けるようになります。