C# Mathクラスの使い方完全ガイド｜計算・丸め・最大値・乱数まで初心者向けに解説

はじめに

C#で数値計算を行うときによく使うのが、標準で用意されているMathクラスです。

たとえば、次のような処理をしたい場面はよくあります。

「2つの数値の大きい方を取得したい」
「小数を四捨五入したい」
「平方根や累乗を計算したい」
「円周率を使って円の面積を求めたい」
「ゲームで距離や角度を計算したい」

このような計算を自分で一から実装する必要はありません。C#ではSystem.Mathクラスを使うことで、数学計算を簡単に書くことができます。

この記事では、C#のMathクラスの基本的な使い方から、最大値・最小値、丸め処理、累乗、平方根、三角関数、乱数、定数、よくある注意点まで、初心者にもわかりやすく解説します。

1. C#のMathクラスとは？できることを初心者向けに解説

C#のMathクラスは、数値計算でよく使う機能をまとめた標準クラスです。

Math.Max、Math.Min、Math.Round、Math.Sqrt、Math.Powなど、計算に便利なメソッドが多数用意されています。Microsoftの公式ドキュメントでも、Mathクラスは三角関数、対数関数、その他の一般的な数学関数の定数と静的メソッドを提供するクラスとして説明されています。

1-1. Mathクラスは数学計算を簡単に行うための標準クラス

Mathクラスを使うと、複雑な計算を短いコードで書けます。

たとえば、平方根を求める場合、自分で計算式を書く必要はありません。

C#
double result = Math.Sqrt(25);
Console.WriteLine(result); // 5

このように、Math.Sqrtを使うだけで平方根を取得できます。

MathクラスはC#の標準ライブラリに含まれているため、特別な外部ライブラリを追加しなくても使えます。

1-2. Mathクラスで使える主な機能一覧

Mathクラスでは、主に次のような処理ができます。

処理内容	メソッド・定数の例
最大値を求める	`Math.Max`
最小値を求める	`Math.Min`
絶対値を求める	`Math.Abs`
正負を判定する	`Math.Sign`
値を範囲内に収める	`Math.Clamp`
四捨五入・丸め	`Math.Round`
切り捨て方向への丸め	`Math.Floor`
切り上げ方向への丸め	`Math.Ceiling`
小数部の切り捨て	`Math.Truncate`
累乗	`Math.Pow`
平方根	`Math.Sqrt`
対数	`Math.Log`、`Math.Log10`
指数関数	`Math.Exp`
三角関数	`Math.Sin`、`Math.Cos`、`Math.Tan`
円周率	`Math.PI`
自然対数の底	`Math.E`

数値計算でよく出てくる処理の多くは、Mathクラスで対応できます。

1-3. Mathクラスを使うメリット

Mathクラスを使うメリットは、次の3つです。

1つ目は、コードが短くわかりやすくなることです。

C#
double distance = Math.Sqrt(x * x + y * y);

このように書けば、「平方根を使って距離を求めている」とすぐにわかります。

2つ目は、標準機能なので信頼性が高いことです。自分で複雑な計算処理を書くよりも、標準ライブラリのメソッドを使った方がミスを減らせます。

3つ目は、初心者でも使いやすいことです。Math.メソッド名()という形で呼び出すだけなので、基本的な文法を知っていればすぐに使えます。

1-4. using Systemは必要？Mathクラスの基本的な呼び出し方

MathクラスはSystem名前空間にあります。

通常のC#ファイルでは、先頭に次のように書くことが多いです。

C#
using System;

その上で、次のようにMathクラスを呼び出します。

C#
int max = Math.Max(10, 20);
Console.WriteLine(max);

using System;を書かない場合は、次のように完全修飾名で書くこともできます。

C#
int max = System.Math.Max(10, 20);
Console.WriteLine(max);

最近の.NETプロジェクトでは、テンプレート設定によってSystemが暗黙的に使える場合もあります。ただし、初心者のうちはusing System;を書いておくと理解しやすいです。

2. C# Mathクラスの基本的な使い方

Mathクラスの使い方はとてもシンプルです。

基本的には、次の形で呼び出します。

C#
Math.メソッド名(引数);

たとえば、2つの数値の大きい方を求める場合は、次のように書きます。

C#
int result = Math.Max(5, 8);

2-1. Math.メソッド名()の基本構文

Mathクラスの基本構文は次のとおりです。

C#
Math.メソッド名(値1, 値2);

例として、最大値、最小値、絶対値を求めてみます。

C#
int max = Math.Max(10, 30);
int min = Math.Min(10, 30);
int abs = Math.Abs(-15);

Console.WriteLine(max); // 30
Console.WriteLine(min); // 10
Console.WriteLine(abs); // 15

Math.Maxは大きい方、Math.Minは小さい方、Math.Absは絶対値を返します。

2-2. Mathクラスはインスタンス化せずに使う

Mathクラスは、インスタンス化せずに使います。

つまり、次のようにnew Math()とは書きません。

C#
// これはできません
// Math math = new Math();

Mathクラスのメソッドは静的メソッドです。そのため、クラス名から直接呼び出します。

C#
double result = Math.Sqrt(16);
Console.WriteLine(result); // 4

「静的メソッド」と聞くと難しく感じるかもしれませんが、初心者のうちは「Math.から直接呼び出す」と覚えれば問題ありません。

2-3. int・double・decimalなど数値型との関係

C#には、いくつかの数値型があります。

型	主な用途
`int`	整数
`long`	大きな整数
`float`	単精度の小数
`double`	倍精度の小数
`decimal`	金額など精度を重視する小数

Mathクラスのメソッドには、複数の型に対応したオーバーロードが用意されているものがあります。

たとえば、Math.Maxはint同士でもdouble同士でも使えます。

C#
int intMax = Math.Max(10, 20);
double doubleMax = Math.Max(10.5, 20.3);

Console.WriteLine(intMax);    // 20
Console.WriteLine(doubleMax); // 20.3

ただし、すべてのメソッドがすべての型に対応しているわけではありません。特にMath.PowやMath.Sqrtは戻り値がdoubleになるため、整数として使いたい場合は型変換が必要になることがあります。

2-4. サンプルコードで見るMathクラスの基本

以下は、Mathクラスの基本的な使い方をまとめたサンプルです。

C#
using System;

class Program
{
    static void Main()
    {
        int a = 10;
        int b = 25;

        Console.WriteLine(Math.Max(a, b));  // 25
        Console.WriteLine(Math.Min(a, b));  // 10
        Console.WriteLine(Math.Abs(-100));  // 100

        double x = 3.6;

        Console.WriteLine(Math.Round(x));   // 4
        Console.WriteLine(Math.Floor(x));   // 3
        Console.WriteLine(Math.Ceiling(x)); // 4

        Console.WriteLine(Math.Pow(2, 3));  // 8
        Console.WriteLine(Math.Sqrt(49));   // 7
    }
}

このように、Mathクラスを使うと、さまざまな計算を簡単に実行できます。

3. 最大値・最小値・絶対値を求めるMathメソッド

ここでは、数値比較や符号判定でよく使うメソッドを解説します。

特に、Math.Max、Math.Min、Math.Absは使用頻度が高いメソッドです。

3-1. Math.Maxで2つの値の大きい方を取得する

Math.Maxは、2つの値を比較して大きい方を返します。

C#
int result = Math.Max(10, 20);
Console.WriteLine(result); // 20

点数の高い方を取得する例です。

C#
int scoreA = 85;
int scoreB = 92;

int highScore = Math.Max(scoreA, scoreB);

Console.WriteLine(highScore); // 92

if文で比較しても同じ処理はできますが、Math.Maxを使うと1行で簡潔に書けます。

C#
int highScore = Math.Max(scoreA, scoreB);

3-2. Math.Minで2つの値の小さい方を取得する

Math.Minは、2つの値を比較して小さい方を返します。

C#
int result = Math.Min(10, 20);
Console.WriteLine(result); // 10

価格が安い方を取得する例です。

C#
int priceA = 1200;
int priceB = 980;

int cheaperPrice = Math.Min(priceA, priceB);

Console.WriteLine(cheaperPrice); // 980

最大値を求めるMath.Maxとセットで覚えると便利です。

3-3. Math.Absで絶対値を取得する

Math.Absは、数値の絶対値を返します。

絶対値とは、符号を取り除いた値のことです。

C#
int result = Math.Abs(-50);
Console.WriteLine(result); // 50

正の数に使った場合は、そのまま同じ値が返ります。

C#
Console.WriteLine(Math.Abs(30));  // 30
Console.WriteLine(Math.Abs(-30)); // 30

差分を求めるときにも便利です。

C#
int current = 80;
int target = 100;

int difference = Math.Abs(current - target);

Console.WriteLine(difference); // 20

ゲームやグラフ処理などで「距離」や「差」を扱うときによく使います。

3-4. Math.Signで正負を判定する

Math.Signは、数値が正の数、負の数、0のどれかを判定するメソッドです。

戻り値は次のようになります。

値	戻り値
正の数	`1`
0	`0`
負の数	`-1`

C#
Console.WriteLine(Math.Sign(100));  // 1
Console.WriteLine(Math.Sign(0));    // 0
Console.WriteLine(Math.Sign(-100)); // -1

移動方向を判定するときにも使えます。

C#
int move = -5;
int direction = Math.Sign(move);

if (direction < 0)
{
    Console.WriteLine("左方向に移動");
}
else if (direction > 0)
{
    Console.WriteLine("右方向に移動");
}
else
{
    Console.WriteLine("停止");
}

3-5. Math.Clampで値を指定範囲内に収める

Math.Clampは、値を指定した最小値から最大値の範囲内に収めるメソッドです。公式ドキュメントでは、valueをminからmaxまでの包括的な範囲にクランプして返すメソッドとして説明されています。

C#
int value = 120;
int result = Math.Clamp(value, 0, 100);

Console.WriteLine(result); // 100

この例では、valueが100を超えているため、結果は上限の100になります。

C#
Console.WriteLine(Math.Clamp(50, 0, 100));   // 50
Console.WriteLine(Math.Clamp(-10, 0, 100));  // 0
Console.WriteLine(Math.Clamp(120, 0, 100));  // 100

入力値を0〜100の範囲に制限したい場合などに便利です。

C#
int hp = 150;
hp = Math.Clamp(hp, 0, 100);

Console.WriteLine(hp); // 100

ゲームのHP、音量、進捗率、スライダーの値など、範囲を超えてほしくない数値に使えます。

4. C#で小数を丸める方法

C#で小数を扱うときは、丸め処理が重要です。

Mathクラスには、小数を丸めるためのメソッドが複数あります。

メソッド	処理内容
`Math.Round`	最も近い値に丸める
`Math.Floor`	小さい方向に丸める
`Math.Ceiling`	大きい方向に丸める
`Math.Truncate`	小数部を切り捨てる

それぞれ似ていますが、負の数を扱うと結果が異なるため注意が必要です。

4-1. Math.Roundで四捨五入する

Math.Roundは、数値を丸めるメソッドです。

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

Console.WriteLine(result); // 4

小数点以下の桁数を指定することもできます。

C#
double value = 3.14159;
double result = Math.Round(value, 2);

Console.WriteLine(result); // 3.14

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

ただし、Math.Roundは日本語でいう一般的な「四捨五入」と完全に同じとは限りません。既定では、中間値を最も近い偶数に丸める動作が使われます。公式ドキュメントでも、Round(Double)やRound(Decimal)は中間値を最も近い偶数に丸めると説明されています。

4-2. Math.Floorで切り捨て方向に丸める

Math.Floorは、指定した数値以下の最大の整数値を返します。

簡単に言うと、「小さい方向」に丸めます。

C#
Console.WriteLine(Math.Floor(3.9));  // 3
Console.WriteLine(Math.Floor(3.1));  // 3

正の数だけを見ると、小数点以下を切り捨てているように見えます。

しかし、負の数では注意が必要です。

C#
Console.WriteLine(Math.Floor(-3.1)); // -4

-3.1より小さい整数は-4なので、結果は-4になります。

4-3. Math.Ceilingで切り上げ方向に丸める

Math.Ceilingは、指定した数値以上の最小の整数値を返します。

簡単に言うと、「大きい方向」に丸めます。

C#
Console.WriteLine(Math.Ceiling(3.1)); // 4
Console.WriteLine(Math.Ceiling(3.9)); // 4

負の数では次のようになります。

C#
Console.WriteLine(Math.Ceiling(-3.1)); // -3

-3.1以上の整数のうち最小の値は-3なので、結果は-3になります。

4-4. Math.Truncateで小数点以下を切り捨てる

Math.Truncateは、小数点以下を単純に取り除きます。

C#
Console.WriteLine(Math.Truncate(3.9));  // 3
Console.WriteLine(Math.Truncate(3.1));  // 3
Console.WriteLine(Math.Truncate(-3.9)); // -3

Math.Floorと違い、負の数でも0に近づく方向に小数部を切り捨てます。

比較すると、違いがわかりやすくなります。

C#
Console.WriteLine(Math.Floor(-3.9));    // -4
Console.WriteLine(Math.Truncate(-3.9)); // -3

「単純に小数点以下を消したい」場合はMath.Truncateを使うとよいでしょう。

4-5. Roundが想定と違う結果になる理由

初心者がつまずきやすいのが、Math.Roundの結果です。

たとえば、次のコードを見てください。

C#
Console.WriteLine(Math.Round(2.5)); // 2
Console.WriteLine(Math.Round(3.5)); // 4

「2.5なら3になるのでは？」と思うかもしれません。

しかし、Math.Roundの既定動作では、ちょうど中間の値を最も近い偶数に丸めます。これを「銀行丸め」や「偶数丸め」と呼ぶことがあります。

そのため、2.5は偶数の2に、3.5は偶数の4に丸められます。

C#
Console.WriteLine(Math.Round(2.5)); // 2
Console.WriteLine(Math.Round(3.5)); // 4
Console.WriteLine(Math.Round(4.5)); // 4
Console.WriteLine(Math.Round(5.5)); // 6

この仕様を知らないと、「C#の四捨五入がおかしい」と感じることがあります。

4-6. MidpointRoundingで丸め方を指定する

一般的な四捨五入のように、.5を0から遠い方向へ丸めたい場合は、MidpointRounding.AwayFromZeroを指定します。

C#
Console.WriteLine(Math.Round(2.5, MidpointRounding.AwayFromZero)); // 3
Console.WriteLine(Math.Round(3.5, MidpointRounding.AwayFromZero)); // 4

小数点以下の桁数も指定できます。

C#
double value = 1.235;

double result = Math.Round(value, 2, MidpointRounding.AwayFromZero);

Console.WriteLine(result); // 1.24

金額計算などで「一般的な四捨五入」を明示したい場合は、MidpointRounding.AwayFromZeroを使うと意図が伝わりやすくなります。

一方、統計処理などで丸め誤差の偏りを抑えたい場合は、既定のMidpointRounding.ToEvenが適している場合もあります。目的に応じて使い分けましょう。

5. 累乗・平方根・対数を計算するMathメソッド

Mathクラスでは、累乗、平方根、対数、指数関数なども計算できます。

数学や物理、統計、ゲーム開発、金融計算などでよく使います。

5-1. Math.Powで累乗を計算する

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

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

この例では、2の3乗を計算しています。

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

C#
2 * 2 * 2

平方を求める場合にも使えます。

C#
double square = Math.Pow(5, 2);
Console.WriteLine(square); // 25

ただし、Math.Powの戻り値はdoubleです。

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

整数として使いたい場合は、必要に応じて型変換します。

C#
int result = (int)Math.Pow(10, 2);
Console.WriteLine(result); // 100

5-2. Math.Sqrtで平方根を求める

Math.Sqrtは、平方根を求めるメソッドです。

C#
double result = Math.Sqrt(25);
Console.WriteLine(result); // 5

平方根とは、「2乗すると元の数になる値」です。

たとえば、5 * 5 = 25なので、25の平方根は5です。

距離計算でもよく使います。

C#
double x = 3;
double y = 4;

double distance = Math.Sqrt(x * x + y * y);

Console.WriteLine(distance); // 5

このコードは、原点から点(3, 4)までの距離を求めています。

5-3. Math.Logで自然対数を求める

Math.Logは、自然対数を求めるメソッドです。

C#
double result = Math.Log(Math.E);
Console.WriteLine(result); // 1

自然対数は、数学や統計、機械学習などで使われることがあります。

底を指定することもできます。

C#
double result = Math.Log(8, 2);
Console.WriteLine(result); // 3

この例では、2を何乗すると8になるかを求めています。

5-4. Math.Log10で常用対数を求める

Math.Log10は、10を底とする対数を求めるメソッドです。

C#
double result = Math.Log10(1000);
Console.WriteLine(result); // 3

10の3乗は1000なので、結果は3です。

常用対数は、桁数の計算や科学技術計算で使われることがあります。

5-5. Math.Expで指数関数を計算する

Math.Expは、自然対数の底eの累乗を計算するメソッドです。

C#
double result = Math.Exp(1);
Console.WriteLine(result); // 2.718281828459045

これは、eの1乗を求めています。

Math.Expは、指数関数的な増加や減少を表す計算で使われます。

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

Console.WriteLine(result);

一般的なアプリ開発では使用頻度は高くありませんが、数学的な処理を扱う場合には重要なメソッドです。

6. 三角関数を使った角度・ラジアン計算

Mathクラスでは、三角関数も利用できます。

代表的なメソッドは、Math.Sin、Math.Cos、Math.Tanです。

ゲーム開発、グラフィック処理、座標計算、角度計算などでよく使います。

6-1. Math.Sin・Math.Cos・Math.Tanの使い方

三角関数の基本的な使い方は次のとおりです。

C#
double angle = Math.PI / 2;

Console.WriteLine(Math.Sin(angle)); // 1
Console.WriteLine(Math.Cos(angle)); // 約0
Console.WriteLine(Math.Tan(angle)); // 非常に大きな値

Math.Sinはサイン、Math.Cosはコサイン、Math.Tanはタンジェントを求めます。

ただし、C#の三角関数では角度を「度」ではなく「ラジアン」で指定します。

6-2. C#の三角関数はラジアンで計算する

C#のMath.Sin、Math.Cos、Math.Tanに渡す角度はラジアンです。

たとえば、90度をそのまま渡してはいけません。

C#
// これは90度として扱われるわけではない
double result = Math.Sin(90);

90は90ラジアンとして扱われます。

90度を使いたい場合は、ラジアンに変換する必要があります。

6-3. 度数法からラジアンへ変換する方法

度をラジアンに変換する公式は次のとおりです。

C#
ラジアン = 度 * Math.PI / 180

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

C#
double degrees = 90;
double radians = degrees * Math.PI / 180;

double result = Math.Sin(radians);

Console.WriteLine(result); // 1

逆に、ラジアンを度に変換する場合は次の式を使います。

C#
度 = ラジアン * 180 / Math.PI

C#
double radians = Math.PI;
double degrees = radians * 180 / Math.PI;

Console.WriteLine(degrees); // 180

角度計算では、この変換がとても重要です。

6-4. Math.PIを使った角度計算

Math.PIは円周率を表す定数です。

C#
Console.WriteLine(Math.PI); // 3.141592653589793

ラジアンでは、主な角度は次のように表されます。

度	ラジアン
0度	`0`
90度	`Math.PI / 2`
180度	`Math.PI`
270度	`Math.PI * 3 / 2`
360度	`Math.PI * 2`

たとえば、180度のコサインを求める場合は次のように書きます。

C#
double result = Math.Cos(Math.PI);

Console.WriteLine(result); // -1

円運動や回転処理では、Math.PIをよく使います。

6-5. Math.Asin・Math.Acos・Math.Atanの使い方

Math.Asin、Math.Acos、Math.Atanは、三角関数の逆関数です。

メソッド	意味
`Math.Asin`	アークサイン
`Math.Acos`	アークコサイン
`Math.Atan`	アークタンジェント

たとえば、サインの値から角度を求める場合はMath.Asinを使います。

C#
double value = 1;
double radians = Math.Asin(value);

Console.WriteLine(radians); // 1.5707963267948966
Console.WriteLine(radians * 180 / Math.PI); // 90

座標から角度を求める場合には、Math.Atan2もよく使います。

C#
double y = 1;
double x = 1;

double radians = Math.Atan2(y, x);
double degrees = radians * 180 / Math.PI;

Console.WriteLine(degrees); // 45

Math.Atan2は、x座標とy座標から角度を求めるときに便利です。

7. C#で乱数を扱う方法

C#でランダムな数値を作りたい場合、MathクラスではなくRandomクラスを使います。

ここは初心者が間違えやすいポイントです。

7-1. MathクラスにRandomメソッドはある？

C#のMathクラスには、乱数を生成するRandomメソッドはありません。

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

C#
// これはできない
// Math.Random();

乱数を作るには、System.Randomクラスを使います。

7-2. 乱数生成にはRandomクラスを使う

Randomクラスは、擬似乱数を生成するためのクラスです。公式ドキュメントでも、Randomクラスは擬似乱数ジェネレーターを表すクラスとして説明されています。

基本的な使い方は次のとおりです。

C#
Random random = new Random();

int number = random.Next();

Console.WriteLine(number);

Randomクラスは、まずインスタンスを作成してから使います。

C#
Random random = new Random();

この点は、Mathクラスと異なります。

7-3. Random.Nextで整数の乱数を作る

整数の乱数を作るには、Random.Nextを使います。

C#
Random random = new Random();

int number = random.Next(10);

Console.WriteLine(number);

このコードでは、0以上10未満の整数が生成されます。

つまり、生成される可能性がある値は0から9です。

範囲を指定することもできます。

C#
Random random = new Random();

int number = random.Next(1, 7);

Console.WriteLine(number);

この例では、1以上7未満の整数が生成されます。

つまり、サイコロのように1から6までの値を作れます。

Random.Next(Int32, Int32)は指定した範囲内のランダムな整数を返し、Random.Next(Int32)は指定した最大値より小さい負でないランダム整数を返すメソッドです。

7-4. Random.NextDoubleで小数の乱数を作る

小数の乱数を作るには、Random.NextDoubleを使います。

C#
Random random = new Random();

double number = random.NextDouble();

Console.WriteLine(number);

NextDoubleは、0.0以上1.0未満のdouble値を返します。

たとえば、0.0〜10.0未満の乱数を作りたい場合は、次のようにします。

C#
Random random = new Random();

double number = random.NextDouble() * 10;

Console.WriteLine(number);

7-5. 指定範囲の乱数を生成するサンプルコード

整数の指定範囲の乱数を生成する例です。

C#
Random random = new Random();

int min = 50;
int max = 101;

int number = random.Next(min, max);

Console.WriteLine(number); // 50〜100

maxは含まれないため、100までを出したい場合は101を指定します。

小数の指定範囲の乱数を生成する場合は、次のように書きます。

C#
Random random = new Random();

double min = 5.0;
double max = 10.0;

double number = min + random.NextDouble() * (max - min);

Console.WriteLine(number); // 5.0以上10.0未満

抽選処理の例も見てみましょう。

C#
Random random = new Random();

int lottery = random.Next(1, 101);

if (lottery <= 10)
{
    Console.WriteLine("当たり");
}
else
{
    Console.WriteLine("はずれ");
}

この例では、1〜100の乱数を作り、10以下なら当たりにしています。

7-6. 乱数生成で初心者が間違えやすいポイント

乱数生成で初心者が間違えやすいポイントは、次の3つです。

1つ目は、Mathクラスで乱数を作ろうとすることです。

C#
// Math.Random() は存在しない

乱数にはRandomクラスを使いましょう。

2つ目は、Nextの上限値が含まれないことです。

C#
random.Next(1, 10);

この場合、生成されるのは1から9までです。10は含まれません。

3つ目は、短時間に何度もnew Random()を作ることです。

C#
// 避けた方がよい例
for (int i = 0; i < 5; i++)
{
    Random random = new Random();
    Console.WriteLine(random.Next(100));
}

通常は、Randomのインスタンスを1つ作って使い回すのがおすすめです。

C#
Random random = new Random();

for (int i = 0; i < 5; i++)
{
    Console.WriteLine(random.Next(100));
}

8. Mathクラスでよく使う定数

Mathクラスには、よく使う数学定数も用意されています。

代表的なのは、Math.PIとMath.Eです。

8-1. Math.PIで円周率を使う

Math.PIは、円周率πを表す定数です。

C#
Console.WriteLine(Math.PI);

出力例は次のようになります。

C#
3.141592653589793

円の面積や円周、角度計算などでよく使います。

C#
double radius = 5;
double area = radius * radius * Math.PI;

Console.WriteLine(area);

8-2. Math.Eで自然対数の底を使う

Math.Eは、自然対数の底eを表す定数です。公式ドキュメントでも、Math.Eは自然対数の底を表すフィールドとして説明されています。

C#
Console.WriteLine(Math.E);

出力例は次のようになります。

C#
2.718281828459045

自然対数や指数関数を扱うときに使います。

C#
double result = Math.Log(Math.E);

Console.WriteLine(result); // 1

8-3. 定数を使った円の面積・円周の計算例

円の面積を求める公式は次のとおりです。

C#
面積 = 半径 × 半径 × 円周率

C#では次のように書けます。

C#
double radius = 10;

double area = radius * radius * Math.PI;

Console.WriteLine(area);

円周を求める公式は次のとおりです。

C#
円周 = 直径 × 円周率

C#では次のように書けます。

C#
double radius = 10;

double circumference = 2 * radius * Math.PI;

Console.WriteLine(circumference);

Math.PIを使うことで、円周率を自分で3.14と書く必要がなくなります。より精度の高い値を使えるため、計算結果も安定します。

9. Mathクラスと基本演算子の使い分け

C#では、すべての計算にMathクラスを使うわけではありません。

足し算や引き算などの基本的な計算は、演算子を使います。

9-1. 足し算・引き算・掛け算・割り算は演算子で行う

基本的な四則演算は、次の演算子を使います。

処理	演算子
足し算	`+`
引き算	`-`
掛け算	`*`
割り算	`/`

C#
int a = 10;
int b = 3;

Console.WriteLine(a + b); // 13
Console.WriteLine(a - b); // 7
Console.WriteLine(a * b); // 30
Console.WriteLine(a / b); // 3

Mathクラスは、最大値、最小値、平方根、累乗、丸めなど、演算子だけでは書きにくい処理に使います。

9-2. 割り算で小数にならない原因

C#で初心者がよくつまずくのが、整数同士の割り算です。

C#
int a = 10;
int b = 3;

Console.WriteLine(a / b); // 3

10 / 3は本来3.333...ですが、int同士の割り算では小数部分が切り捨てられます。

小数として計算したい場合は、どちらかをdoubleにします。

C#
int a = 10;
int b = 3;

double result = (double)a / b;

Console.WriteLine(result); // 3.3333333333333335

または、最初からdouble型を使います。

C#
double a = 10;
double b = 3;

Console.WriteLine(a / b);

9-3. 剰余は%演算子を使う

割り算の余りを求めるには、%演算子を使います。

C#
int result = 10 % 3;

Console.WriteLine(result); // 1

偶数・奇数の判定にも使えます。

C#
int number = 7;

if (number % 2 == 0)
{
    Console.WriteLine("偶数");
}
else
{
    Console.WriteLine("奇数");
}

Mathクラスには剰余専用の基本メソッドを探すより、通常は%演算子を使うのが自然です。

9-4. Mathクラスを使うべき場面

Mathクラスを使うべき場面は、次のような処理です。

やりたいこと	使うもの
2つの値の大きい方を求める	`Math.Max`
2つの値の小さい方を求める	`Math.Min`
絶対値を求める	`Math.Abs`
小数を丸める	`Math.Round`
小さい方向に丸める	`Math.Floor`
大きい方向に丸める	`Math.Ceiling`
累乗を求める	`Math.Pow`
平方根を求める	`Math.Sqrt`
角度計算をする	`Math.Sin`、`Math.Cos`、`Math.Tan`
円周率を使う	`Math.PI`

単純な四則演算は演算子、数学的な処理はMathクラス、と考えるとわかりやすいです。

9-5. 計算結果の型変換に注意する

Mathクラスを使うときは、戻り値の型に注意しましょう。

たとえば、Math.Powはdoubleを返します。

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

次のようにintへ直接代入するとエラーになります。

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

intとして使いたい場合は、キャストが必要です。

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

Console.WriteLine(result); // 8

ただし、小数部分がある値をintに変換すると、小数部分が失われます。

C#
int value = (int)3.9;

Console.WriteLine(value); // 3

型変換を行うときは、意図した結果になるか確認しましょう。

10. Mathクラスでよくあるエラーと注意点

Mathクラスは便利ですが、使い方を間違えると予想外の結果になることがあります。

ここでは、初心者が特に注意すべきポイントを解説します。

10-1. Math.Powの戻り値がdoubleになる

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

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

整数の累乗を計算していても、結果はdoubleになります。

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

整数として扱いたい場合は、次のようにキャストします。

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

Console.WriteLine(result); // 1024

ただし、非常に大きな値では精度や範囲に注意が必要です。

10-2. 整数同士の割り算で小数が消える

Mathクラスとは直接関係ありませんが、数値計算でよくあるミスです。

C#
int total = 5;
int count = 2;

double average = total / count;

Console.WriteLine(average); // 2

averageはdoubleですが、右辺のtotal / countが整数同士の割り算なので、結果は2になります。

正しく小数を出すには、次のようにします。

C#
double average = (double)total / count;

Console.WriteLine(average); // 2.5

平均値、割合、単価などを計算するときは特に注意しましょう。

10-3. decimalとdoubleを混在させるとエラーになる

decimalとdoubleは、どちらも小数を扱う型ですが、そのまま混在させることはできません。

C#
decimal price = 1000m;
double rate = 1.1;

// エラー
// var result = price * rate;

decimalを使うなら、値もdecimalにそろえます。

C#
decimal price = 1000m;
decimal rate = 1.1m;

decimal result = price * rate;

Console.WriteLine(result);

金額計算では、一般的にdecimalを使うことが多いです。

C#
decimal taxRate = 0.10m;
decimal price = 1200m;

decimal tax = price * taxRate;

doubleとdecimalを混ぜるとエラーになるため、どちらの型を使うかを決めて統一しましょう。

10-4. 負の数にMath.Sqrtを使うとNaNになる

Math.Sqrtに負の数を渡すと、通常の実数としては平方根を求められないため、NaNになります。

C#
double result = Math.Sqrt(-1);

Console.WriteLine(result); // NaN

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

計算前に負の数でないか確認すると安全です。

C#
double value = -1;

if (value < 0)
{
    Console.WriteLine("負の数の平方根は計算できません");
}
else
{
    Console.WriteLine(Math.Sqrt(value));
}

距離計算などでは通常マイナスになりにくいですが、入力値を扱う場合はチェックしておくと安心です。

10-5. オーバーフローや精度誤差に注意する

数値計算では、オーバーフローや精度誤差にも注意が必要です。

たとえば、intには扱える範囲があります。

C#
int max = int.MaxValue;
Console.WriteLine(max);

範囲を超える計算を行うと、期待しない結果になることがあります。

また、doubleは小数を2進数で表現するため、一部の小数を正確に表せません。

C#
double result = 0.1 + 0.2;

Console.WriteLine(result); // 0.30000000000000004

このような誤差は、Math.Roundの結果が予想と違う原因になることもあります。

金額のように正確な10進計算が必要な場合は、decimalを検討しましょう。

C#
decimal result = 0.1m + 0.2m;

Console.WriteLine(result); // 0.3

11. 実用シーン別C# Mathクラスのサンプル集

ここでは、実際の開発で使いやすいMathクラスのサンプルを紹介します。

11-1. 消費税や料金計算で小数を丸める

消費税を計算して、小数点以下を丸める例です。

C#
decimal price = 1980m;
decimal taxRate = 0.10m;

decimal tax = price * taxRate;
decimal roundedTax = Math.Round(tax, 0, MidpointRounding.AwayFromZero);

Console.WriteLine(roundedTax); // 198

合計金額を求める場合は次のようにします。

C#
decimal price = 1980m;
decimal taxRate = 0.10m;

decimal tax = Math.Round(price * taxRate, 0, MidpointRounding.AwayFromZero);
decimal total = price + tax;

Console.WriteLine(total);

料金計算では、丸め方が仕様として決まっていることが多いため、MidpointRoundingを明示すると安全です。

11-2. ゲーム開発で距離や角度を計算する

2点間の距離を求める例です。

C#
double x1 = 0;
double y1 = 0;
double x2 = 3;
double y2 = 4;

double dx = x2 - x1;
double dy = y2 - y1;

double distance = Math.Sqrt(dx * dx + dy * dy);

Console.WriteLine(distance); // 5

角度を求める例です。

C#
double x = 1;
double y = 1;

double radians = Math.Atan2(y, x);
double degrees = radians * 180 / Math.PI;

Console.WriteLine(degrees); // 45

キャラクターの向き、弾の発射方向、カメラ回転などで役立ちます。

11-3. ランキング処理で最大値・最小値を求める

配列から最大値と最小値を求める例です。

C#
int[] scores = { 80, 95, 72, 88, 100 };

int max = scores[0];
int min = scores[0];

foreach (int score in scores)
{
    max = Math.Max(max, score);
    min = Math.Min(min, score);
}

Console.WriteLine($"最高点: {max}");
Console.WriteLine($"最低点: {min}");

Math.MaxとMath.Minを使うことで、比較処理をシンプルに書けます。

11-4. 入力値を範囲内に制限する

ユーザーが入力した値を0〜100に制限する例です。

C#
int input = 135;

int value = Math.Clamp(input, 0, 100);

Console.WriteLine(value); // 100

音量を制限する例です。

C#
int volume = -20;

volume = Math.Clamp(volume, 0, 100);

Console.WriteLine(volume); // 0

範囲チェックをif文で書くこともできますが、Math.Clampを使うと短く書けます。

C#
value = Math.Clamp(value, min, max);

11-5. ランダムな数値を使って抽選処理を作る

ランダムな数値を使って抽選処理を作る例です。

C#
Random random = new Random();

int number = random.Next(1, 101);

if (number <= 5)
{
    Console.WriteLine("大当たり");
}
else if (number <= 30)
{
    Console.WriteLine("当たり");
}
else
{
    Console.WriteLine("はずれ");
}

この例では、1〜100の乱数を生成し、次のように判定しています。

条件	結果
1〜5	大当たり
6〜30	当たり
31〜100	はずれ

ゲームのガチャ、抽選、ランダムイベントなどで使える考え方です。

12. C# Mathクラスに関するよくある質問

最後に、C#のMathクラスに関するよくある質問をまとめます。

12-1. C#のMathクラスを使うには何をインポートする？

MathクラスはSystem名前空間にあります。

通常は、ファイルの先頭に次のように書きます。

C#
using System;

そして、次のように呼び出します。

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

using System;を書かない場合は、次のように書けます。

C#
double result = System.Math.Sqrt(16);

12-2. Math.Roundは本当に四捨五入？

Math.Roundは、一般的な意味での四捨五入と完全に同じとは限りません。

既定では、.5のような中間値を最も近い偶数に丸めます。

C#
Console.WriteLine(Math.Round(2.5)); // 2
Console.WriteLine(Math.Round(3.5)); // 4

一般的な四捨五入のようにしたい場合は、MidpointRounding.AwayFromZeroを指定します。

C#
Console.WriteLine(Math.Round(2.5, MidpointRounding.AwayFromZero)); // 3
Console.WriteLine(Math.Round(3.5, MidpointRounding.AwayFromZero)); // 4

12-3. Mathクラスで乱数は作れる？

Mathクラスでは乱数を作れません。

乱数を作るには、Randomクラスを使います。

C#
Random random = new Random();

int number = random.Next(1, 101);

Console.WriteLine(number);

Math.Random()のようなメソッドは存在しないため注意しましょう。

12-4. MathFクラスとの違いは？

MathFクラスは、float向けの数学関数を提供するクラスです。

Mathクラスは主にdoubleを扱うのに対し、MathFはfloatを扱います。公式ドキュメントでも、MathFは三角関数、対数関数、その他の一般的な数学関数の定数と静的メソッドを提供するクラスとして説明されています。

例を見てみましょう。

C#
double result1 = Math.Sqrt(16.0);
float result2 = MathF.Sqrt(16.0f);

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

通常のアプリ開発ではMathを使う場面が多いですが、floatを多用するゲーム開発やグラフィック処理ではMathFが便利な場合があります。

12-5. decimal型の計算にもMathクラスは使える？

一部のMathメソッドはdecimal型にも対応しています。

たとえば、Math.Round、Math.Floor、Math.Ceiling、Math.Truncate、Math.Abs、Math.Max、Math.Minなどはdecimalで使える場合があります。

C#
decimal price = 1234.56m;

decimal rounded = Math.Round(price, 0, MidpointRounding.AwayFromZero);

Console.WriteLine(rounded); // 1235

ただし、Math.SqrtやMath.Powは基本的にdoubleを使うため、decimalをそのまま渡せない場合があります。

C#
decimal value = 16m;

// エラーになる
// decimal result = Math.Sqrt(value);

必要であれば、doubleに変換します。

C#
decimal value = 16m;

double result = Math.Sqrt((double)value);

Console.WriteLine(result); // 4

ただし、金額計算などで精度が重要な場合は、安易にdoubleへ変換しないよう注意しましょう。

まとめ

C#のMathクラスは、数学計算を簡単に行うための標準クラスです。

最大値を求めるMath.Max、最小値を求めるMath.Min、絶対値を求めるMath.Abs、小数を丸めるMath.Round、平方根を求めるMath.Sqrt、累乗を計算するMath.Powなど、実用的なメソッドが数多く用意されています。

基本的な四則演算は+、-、*、/などの演算子を使い、丸め処理や三角関数、対数、平方根、範囲制限などはMathクラスを使うとよいでしょう。

特に初心者が注意すべきポイントは、次のとおりです。

Math.Roundの既定動作は一般的な四捨五入とは異なる場合があります。
Math.Powの戻り値はdoubleです。
整数同士の割り算では小数部分が消えます。
decimalとdoubleはそのまま混在できません。
乱数を作るにはMathではなくRandomクラスを使います。
三角関数では度ではなくラジアンを使います。

Mathクラスを使いこなせるようになると、C#での数値計算がかなり書きやすくなります。まずはMath.Max、Math.Min、Math.Round、Math.Sqrt、Math.Powあたりから覚えて、実際のコードで少しずつ使ってみましょう。