C#で二乗する方法｜Math.Powとx*xの違い、^演算子の注意点まで解説
はじめに
C#で二乗する方法を調べると、Math.Powを使う書き方や、x * xのように自分自身を掛ける書き方が出てきます。
また、他の言語を使った経験がある人は、x ^ 2のように書けば二乗できると思うかもしれません。しかし、C#の^演算子は累乗ではないため注意が必要です。
この記事では、C#で二乗する基本的な方法から、Math.Powとx * xの違い、戻り値の型、オーバーフロー、^演算子の注意点までわかりやすく解説します。
1. C#で二乗する基本的な方法
1-1. 二乗とは「同じ数を2回掛ける」計算
二乗とは、ある数を自分自身で掛ける計算です。
たとえば、5の二乗は次のようになります。
C#5 * 5
結果は25です。
数学では「5²」のように表しますが、C#ではそのまま5²とは書けません。プログラム上では、演算子やメソッドを使って二乗を表現します。
1-2. C#で二乗する代表的な書き方はMath.Powとx * x
C#で二乗する代表的な方法は、主に次の2つです。
C#Math.Pow(x, 2)
または、
C#x * x
Math.Pow(x, 2)は、累乗を計算するためのメソッドです。第1引数に底となる数、第2引数に指数を指定します。
一方、x * xは、変数xをそのまま自分自身で掛ける書き方です。二乗だけを計算したい場合は、こちらの方がシンプルです。
1-3. 結論：単純な二乗ならx * xがわかりやすく高速
C#で単純に二乗したいだけなら、基本的にはx * xを使うのがおすすめです。
理由は、次のとおりです。
C#int x = 5;
int result = x * x;
この書き方は、見た目にも「同じ数を掛けている」とわかりやすく、戻り値の型も自然です。
一方、Math.Pow(x, 2)は戻り値がdoubleになるため、整数として使いたい場合はキャストが必要になることがあります。
2. Math.Powで二乗する方法
2-1. Math.Pow(x, 2)の基本構文
Math.Powを使って二乗する場合は、次のように書きます。
C#Math.Pow(x, 2)
たとえば、5の二乗を計算する場合は次のようになります。
C#double result = Math.Pow(5, 2);
Console.WriteLine(result);
実行結果は次のとおりです。
25
Math.Powは累乗を計算するメソッドなので、二乗だけでなく三乗や四乗などにも使えます。
C#double square = Math.Pow(5, 2); // 5の二乗
double cube = Math.Pow(5, 3); // 5の三乗
2-2. intやdoubleでMath.Powを使うサンプルコード
int型の値をMath.Powで二乗する例です。
C#int x = 10;
double result = Math.Pow(x, 2);
Console.WriteLine(result);
実行結果は次のとおりです。
100
double型の値を二乗する場合も同じように書けます。
C#double x = 2.5;
double result = Math.Pow(x, 2);
Console.WriteLine(result);
実行結果は次のとおりです。
6.25
このように、Math.Powは整数でも小数でも使えます。
2-3. Math.Powの戻り値はdoubleになる点に注意
Math.Powを使うときに特に注意したいのが、戻り値の型です。
Math.Powの戻り値はdoubleです。そのため、次のようにint型の変数へ直接代入しようとするとエラーになります。
C#int x = 5;
int result = Math.Pow(x, 2); // エラー
Math.Pow(x, 2)の結果は25に見えますが、型としてはdoubleです。intに代入したい場合は、明示的なキャストが必要です。
C#int x = 5;
int result = (int)Math.Pow(x, 2);
Console.WriteLine(result);
ただし、小数を含む計算結果をintにキャストすると、小数点以下が切り捨てられる点に注意しましょう。
2-4. 小数や累乗計算にMath.Powが向いているケース
Math.Powは、二乗以外の累乗を扱いたい場合に便利です。
C#double x = 3;
double result1 = Math.Pow(x, 2); // 二乗
double result2 = Math.Pow(x, 3); // 三乗
double result3 = Math.Pow(x, 4); // 四乗
また、指数を変数で指定したい場合にも向いています。
C#double x = 2;
double exponent = 5;
double result = Math.Pow(x, exponent);
Console.WriteLine(result);
このように、二乗に限らず「何乗するかわからない」「指数が変わる」という場合は、Math.Powを使うと柔軟に書けます。
3. x * xで二乗する方法
3-1. 変数を自分自身で掛ける基本構文
C#で二乗するもっともシンプルな方法は、変数を自分自身で掛ける方法です。
C#x * x
たとえば、5の二乗を計算する場合は次のように書きます。
C#int x = 5;
int result = x * x;
Console.WriteLine(result);
実行結果は次のとおりです。
25
この書き方は、二乗の意味そのものをコードで表しているため、初心者にも理解しやすいです。
3-2. int・long・doubleでx * xを使うサンプルコード
int型で二乗する例です。
C#int x = 12;
int result = x * x;
Console.WriteLine(result);
実行結果は次のとおりです。
144
long型でも同じように書けます。
C#long x = 100000L;
long result = x * x;
Console.WriteLine(result);
double型の小数を二乗することもできます。
C#double x = 1.5;
double result = x * x;
Console.WriteLine(result);
実行結果は次のとおりです。
2.25
x * xは、int、long、float、double、decimalなど、掛け算ができる型であれば自然に使えます。
3-3. 単純な二乗ではx * xが読みやすく処理も軽い理由
単純な二乗では、Math.Pow(x, 2)よりもx * xの方がわかりやすいことが多いです。
C#int result = x * x;
このコードは、「xをxで掛ける」とそのまま読めます。
一方、Math.Pow(x, 2)は累乗計算用の汎用的なメソッドです。
C#double result = Math.Pow(x, 2);
二乗だけをしたい場合には、少し大げさな書き方に見えることがあります。また、戻り値がdoubleになるため、整数計算では型変換が必要になることもあります。
そのため、単純なC#の二乗計算では、基本的にx * xを選ぶとよいでしょう。
3-4. オーバーフローに注意すべきケース
整数の二乗では、オーバーフローに注意が必要です。
たとえば、int型の範囲を超える結果になる場合、正しい値が入らないことがあります。
C#int x = 50000;
int result = x * x;
Console.WriteLine(result);
50000 * 50000は2,500,000,000ですが、これはint型の最大値を超えます。
安全に扱いたい場合は、longを使います。
C#int x = 50000;
long result = (long)x * x;
Console.WriteLine(result);
また、オーバーフローを検出したい場合はcheckedを使えます。
C#int x = 50000;
checked
{
int result = x * x;
Console.WriteLine(result);
}
checkedを使うと、オーバーフローが発生したときに例外として検出できます。
4. Math.Powとx * xの違い
4-1. 戻り値の型の違い
Math.Powとx * xの大きな違いは、戻り値の型です。
Math.Powの戻り値はdoubleです。
C#int x = 5;
double result = Math.Pow(x, 2);
一方、x * xは、基本的に掛け算に使った型に応じた結果になります。
C#int x = 5;
int result = x * x;
整数を二乗して整数として扱いたい場合は、x * xの方が自然です。
4-2. 処理速度・パフォーマンスの違い
単純な二乗だけであれば、x * xの方が処理は軽いです。
Math.Powは、二乗だけでなくさまざまな累乗に対応する汎用的なメソッドです。そのため、ただ1回掛け算するだけのx * xと比べると、処理としては複雑になります。
大量のデータをループで二乗するような処理では、x * xを使う方が適しています。
C#for (int i = 0; i < 1000000; i++)
{
int square = i * i;
}
二乗だけで十分な場面では、無理にMath.Powを使う必要はありません。
4-3. コードの読みやすさの違い
二乗だけを表したいなら、x * xは非常に読みやすいです。
C#int square = x * x;
変数名を工夫すれば、さらに意味が明確になります。
C#int width = 10;
int area = width * width;
一方で、指数が変わる処理ではMath.Powの方が意図を表しやすくなります。
C#double result = Math.Pow(x, exponent);
このように、二乗だけならx * x、指数を柔軟に変えたいならMath.Powという使い分けがわかりやすいです。
4-4. 整数計算と小数計算での使い分け
整数の二乗では、x * xがおすすめです。
C#int x = 8;
int result = x * x;
小数の二乗でも、単純な二乗ならx * xで問題ありません。
C#double x = 2.5;
double result = x * x;
ただし、小数の累乗や指数を変えたい場合は、Math.Powが便利です。
C#double x = 2.5;
double result = Math.Pow(x, 3);
整数計算ではx * x、累乗計算ではMath.Powを使う、と覚えるとよいでしょう。
4-5. 二乗だけならどちらを使うべきか
C#で二乗するだけなら、基本的にはx * xを使うのがおすすめです。
C#int square = x * x;
理由は、次のとおりです。
x * xはコードが短く、意味が直感的で、戻り値の型も扱いやすいです。また、単純な掛け算なので処理も軽くなります。
一方、Math.Powは次のような場合に使うとよいでしょう。
C#double result = Math.Pow(x, exponent);
指数が変わる場合や、二乗以外の累乗を計算したい場合にはMath.Powが便利です。
5. C#の^演算子で二乗できない理由
5-1. ^は累乗ではなくビット排他的論理和
C#では、^演算子は累乗ではありません。
C#int result = 2 ^ 2;
このコードを見ると、他の言語に慣れている人は「2の二乗で4になる」と思うかもしれません。
しかし、C#の^はビット排他的論理和、つまりXORを表す演算子です。
そのため、x ^ 2と書いても、xの二乗にはなりません。
5-2. 2 ^ 2の結果が4にならないケース
実際に2 ^ 2を実行してみます。
C#int result = 2 ^ 2;
Console.WriteLine(result);
実行結果は次のとおりです。
0
これは、2と2のビット排他的論理和を計算しているためです。
2を2進数で表すと、次のようになります。
10
同じ値同士のXORは0になるため、2 ^ 2の結果は0です。
二乗したい場合は、次のように書きます。
C#int result = 2 * 2;
または、
C#double result = Math.Pow(2, 2);
5-3. 他言語経験者が間違えやすいポイント
C#以外の言語やツールでは、^が累乗のように使われる場合があります。
そのため、次のようなコードを書いてしまうことがあります。
C#int x = 5;
int result = x ^ 2;
しかし、C#ではこれは二乗ではありません。
二乗したいなら、次のように書きます。
C#int result = x * x;
C#で「二乗」「累乗」と聞いたときに、^を使わないことが重要です。
5-4. C#で累乗したい場合はMath.Powを使う
C#で累乗を計算したい場合は、Math.Powを使います。
C#double result = Math.Pow(2, 10);
Console.WriteLine(result);
実行結果は次のとおりです。
1024
二乗だけならx * xで十分ですが、三乗、四乗、十乗のような計算ではMath.Powが便利です。
C#double square = Math.Pow(3, 2);
double cube = Math.Pow(3, 3);
double fourth = Math.Pow(3, 4);
6. 型変換と戻り値でつまずきやすいポイント
6-1. Math.Powの結果をintに代入するとエラーになる理由
Math.Powの戻り値はdoubleです。
そのため、次のコードはエラーになります。
C#int x = 5;
int result = Math.Pow(x, 2);
Math.Pow(x, 2)の結果は数値としては25ですが、型はdoubleです。C#では、doubleからintへの変換は自動では行われません。
理由は、小数点以下の情報が失われる可能性があるためです。
6-2. intに戻したい場合のキャスト方法
Math.Powの結果をintにしたい場合は、明示的にキャストします。
C#int x = 5;
int result = (int)Math.Pow(x, 2);
Console.WriteLine(result);
ただし、二乗だけなら最初からx * xを使う方が自然です。
C#int x = 5;
int result = x * x;
整数の二乗を整数で受け取りたいなら、基本的にはこちらを使うとよいでしょう。
6-3. 小数点以下の扱いと丸め誤差
doubleは小数を扱えますが、すべての小数を正確に表現できるわけではありません。
たとえば、小数の計算ではわずかな誤差が出ることがあります。
C#double x = 0.1;
double result = x * x;
Console.WriteLine(result);
期待する値は0.01ですが、内部的にはわずかな誤差を含む場合があります。
金額計算のように正確な小数計算が必要な場合は、decimal型を検討します。
C#decimal x = 0.1m;
decimal result = x * x;
Console.WriteLine(result);
6-4. decimal型で二乗したい場合の考え方
decimal型で二乗したい場合は、基本的にx * xを使います。
C#decimal price = 12.5m;
decimal result = price * price;
Console.WriteLine(result);
Math.Powはdoubleを返すため、decimalの精度を保ちたい計算には向いていません。
たとえば、次のようにdecimalをdoubleに変換してMath.Powを使うこともできます。
C#decimal x = 12.5m;
decimal result = (decimal)Math.Pow((double)x, 2);
しかし、この方法ではdoubleを経由するため、正確な小数計算が必要な場面では避けた方がよいです。
decimalで二乗するなら、次の書き方が基本です。
C#decimal result = x * x;
7. 用途別：C#で二乗する実践例
7-1. 整数を二乗するサンプル
整数を二乗する基本例です。
C#int number = 7;
int square = number * number;
Console.WriteLine(square);
実行結果は次のとおりです。
49
整数を二乗して整数として扱うなら、x * xがもっともシンプルです。
7-2. 小数を二乗するサンプル
小数を二乗する場合も、x * xで書けます。
C#double number = 3.5;
double square = number * number;
Console.WriteLine(square);
実行結果は次のとおりです。
12.25
floatを使う場合は、次のようになります。
C#float number = 1.5f;
float square = number * number;
Console.WriteLine(square);
小数の累乗を柔軟に扱いたい場合は、Math.Powも使えます。
C#double number = 3.5;
double square = Math.Pow(number, 2);
7-3. 配列やリストの各要素を二乗するサンプル
配列の各要素を二乗する例です。
C#int[] numbers = { 1, 2, 3, 4, 5 };
for (int i = 0; i < numbers.Length; i++)
{
numbers[i] = numbers[i] * numbers[i];
}
foreach (int number in numbers)
{
Console.WriteLine(number);
}
実行結果は次のとおりです。
1
4
9
16
25
List<int>でも同じように処理できます。
C#List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
for (int i = 0; i < numbers.Count; i++)
{
numbers[i] = numbers[i] * numbers[i];
}
foreach (int number in numbers)
{
Console.WriteLine(number);
}
7-4. LINQで各要素を二乗するサンプル
LINQを使うと、各要素を二乗した新しいコレクションを簡潔に作れます。
C#using System;
using System.Linq;
int[] numbers = { 1, 2, 3, 4, 5 };
var squares = numbers.Select(x => x * x);
foreach (int square in squares)
{
Console.WriteLine(square);
}
実行結果は次のとおりです。
1
4
9
16
25
Math.Powを使うこともできます。
C#var squares = numbers.Select(x => Math.Pow(x, 2));
ただし、この場合の結果はdoubleになります。整数の二乗として扱いたいなら、x * xの方が自然です。
7-5. 距離計算や平方和で二乗を使うサンプル
二乗は、距離計算や平方和でもよく使われます。
たとえば、2点間の距離を求める場合です。
C#double x1 = 1;
double y1 = 2;
double x2 = 4;
double y2 = 6;
double dx = x2 - x1;
double dy = y2 - y1;
double distance = Math.Sqrt(dx * dx + dy * dy);
Console.WriteLine(distance);
dx * dxとdy * dyで、それぞれの差を二乗しています。
平方和を求める例も見てみましょう。
C#int[] numbers = { 1, 2, 3, 4 };
int sumOfSquares = 0;
foreach (int number in numbers)
{
sumOfSquares += number * number;
}
Console.WriteLine(sumOfSquares);
実行結果は次のとおりです。
30
1 * 1 + 2 * 2 + 3 * 3 + 4 * 4なので、結果は30です。
8. C#で二乗するメソッドを自作する方法
8-1. intを受け取って二乗を返すメソッド
二乗処理を何度も使う場合は、メソッド化すると読みやすくなります。
C#static int Square(int x)
{
return x * x;
}
使い方は次のとおりです。
C#int result = Square(6);
Console.WriteLine(result);
実行結果は次のとおりです。
36
メソッド名をSquareにしておくと、「二乗する処理」であることが明確になります。
8-2. doubleを受け取って二乗を返すメソッド
小数を二乗したい場合は、double型のメソッドを用意します。
C#static double Square(double x)
{
return x * x;
}
使い方は次のとおりです。
C#double result = Square(2.5);
Console.WriteLine(result);
実行結果は次のとおりです。
6.25
int版とdouble版をオーバーロードしておくこともできます。
C#static int Square(int x)
{
return x * x;
}
static double Square(double x)
{
return x * x;
}
8-3. ジェネリックで二乗処理を書く場合の注意点
C#でジェネリックな二乗メソッドを書きたい場合、単純に次のようには書けません。
C#static T Square<T>(T x)
{
return x * x; // エラーになる
}
通常のジェネリック型Tに対して、*演算子が使えるとは限らないためです。
比較的新しいC#では、数値型向けのインターフェースを使ってジェネリックな数値計算を書く方法もあります。
C#using System.Numerics;
static T Square<T>(T x) where T : INumber<T>
{
return x * x;
}
ただし、初心者向けのコードや対応環境を広くしたい場合は、int用、double用、decimal用のように型ごとにメソッドを用意する方がわかりやすいです。
8-4. 可読性を高めるためにメソッド化すべきケース
単純に1回だけ二乗するなら、メソッド化せずにx * xで十分です。
C#int square = x * x;
しかし、同じ処理が何度も出てくる場合や、計算式の意味を明確にしたい場合はメソッド化が有効です。
C#static double Square(double x)
{
return x * x;
}
たとえば、距離計算では次のように書けます。
C#double distance = Math.Sqrt(Square(dx) + Square(dy));
このようにすると、dxとdyを二乗して足していることがわかりやすくなります。
9. C#で二乗するときのよくあるエラーと対処法
9-1. Math.Powの戻り値をintに代入できない
よくあるエラーの1つが、Math.Powの戻り値をintに直接代入してしまうケースです。
C#int x = 10;
int result = Math.Pow(x, 2); // エラー
Math.Powはdoubleを返すため、intには直接代入できません。
対処法は、キャストすることです。
C#int result = (int)Math.Pow(x, 2);
ただし、二乗だけなら次のように書く方がおすすめです。
C#int result = x * x;
9-2. ^演算子を使って想定外の結果になる
C#では、^は累乗ではなくXORです。
C#int result = 5 ^ 2;
Console.WriteLine(result);
このコードは、5の二乗を計算しているわけではありません。
二乗したい場合は、次のように書きます。
C#int result = 5 * 5;
または、
C#double result = Math.Pow(5, 2);
C#で二乗する場合、^を使わないようにしましょう。
9-3. 大きな数を二乗してオーバーフローする
整数を二乗すると、想像以上に大きな値になることがあります。
C#int x = 50000;
int result = x * x;
このような場合、intの範囲を超えてオーバーフローする可能性があります。
対処法として、より大きな型を使います。
C#int x = 50000;
long result = (long)x * x;
また、オーバーフローを検出したい場合はcheckedを使います。
C#checked
{
int result = x * x;
}
9-4. 小数計算で誤差が出る
doubleを使った小数計算では、わずかな誤差が出ることがあります。
C#double x = 0.1;
double result = x * x;
Console.WriteLine(result);
小数の計算結果を厳密に扱いたい場合は、decimalを検討します。
C#decimal x = 0.1m;
decimal result = x * x;
Console.WriteLine(result);
ただし、decimalは主に金額計算などに向いており、科学技術計算ではdoubleが使われることも多いです。用途に応じて型を選びましょう。
9-5. 負の数を二乗したときの結果を誤解する
負の数を二乗すると、結果は正の数になります。
C#int x = -5;
int result = x * x;
Console.WriteLine(result);
実行結果は次のとおりです。
25
-5 * -5なので、結果は25です。
ただし、式の書き方によって意味が変わることがあります。
C#int result1 = -5 * -5; // 25
double result2 = Math.Pow(-5, 2); // 25
負の値を二乗する場合も、基本的にはx * xで問題ありません。
まとめ
C#で二乗する方法は、主にMath.Pow(x, 2)とx * xの2つです。
単純に二乗したいだけなら、基本的にはx * xを使うのがおすすめです。
C#int x = 5;
int result = x * x;
x * xは読みやすく、処理も軽く、整数計算では戻り値の型も扱いやすいです。
一方、Math.Powは累乗を計算するためのメソッドです。
C#double result = Math.Pow(x, 2);
二乗以外の累乗や、指数を変数で指定したい場合にはMath.Powが便利です。ただし、戻り値がdoubleになる点には注意しましょう。
また、C#の^演算子は累乗ではなく、ビット排他的論理和です。
C#int result = 2 ^ 2; // 二乗ではない
C#で二乗したい場合は、^ではなく、x * xまたはMath.Pow(x, 2)を使いましょう。