演算子

【C#】mod関数と%演算子の使い方・負の数の挙動・活用例をわかりやすく解説

2025-05-20更新日: 2025-05-20

C#のmodは演算子%で扱い、整数を割った余りを返します。

被除数の符号がそのまま余りの符号になるため、-7 % 3 は -1 になる点が最大の注意点です。

非整数ではMath.IEEERemainderを使うとIEEE754準拠の結果が得られます。

配列の循環や周期計算など日常的に活躍します。

目次から探す

modと%演算子の基本
- シンタックスと評価順序
- 戻り値の型と数値範囲
対応データ型とキャスト
負の数を含む計算の挙動
浮動小数点数の剰余
よく使うユースケース
エラーと例外への備え
- 除数 0 のときの挙動
- checked コンテキストとオーバーフロー
パフォーマンスの考察
独自の Modulo 実装例
- 正の余りを保証する拡張メソッド
- ジェネリック化の設計ポイント
他言語との比較
コーディングスタイルと可読性
- 名前付けとマジックナンバー排除
- 品質確認のポイント
まとめ

modと%演算子の基本

C#で剰余を計算する際に最もよく使われるのが%演算子です。

これは「mod関数」と呼ばれることもありますが、C#の標準機能としては%演算子が剰余計算の役割を担っています。

ここでは、%演算子の基本的な使い方や評価の順序、戻り値の型や数値範囲について詳しく解説します。

シンタックスと評価順序

%演算子は、2つの数値の剰余を計算するための二項演算子です。

基本的な構文は以下の通りです。

result = dividend % divisor;

dividend：被除数(割られる数)
divisor：除数(割る数)
result：剰余(余り)

例えば、7を3で割った余りを求める場合は次のように書きます。

int result = 7 % 3; // 結果は1

この場合、7 ÷ 3 の商は2で余りが1なので、resultには1が格納されます。

評価順序について

%演算子は算術演算子の中で乗算*、除算/と同じ優先順位を持ちます。

つまり、式の中で*や/と混在している場合は左から右へ順に評価されます。

例を見てみましょう。

int result = 10 + 6 % 4 * 2;

この式は以下の順序で評価されます。

6 % 4 → 6を4で割った余りは2
2 * 2 → 4
10 + 4 → 14

したがって、resultは14になります。

演算子の優先順位を明確にしたい場合は、括弧を使うとわかりやすくなります。

int result = 10 + (6 % 4) * 2;

このように書くと、%演算子が先に評価されることが明示されます。

戻り値の型と数値範囲

%演算子の戻り値の型は、基本的に被除数と除数の型に依存します。

C#では、演算子の両辺が同じ型である場合、その型のまま結果が返されます。

被除数の型	除数の型	戻り値の型
int	int	int
long	long	long
short	short	int
byte	byte	int
uint	uint	uint
ulong	ulong	ulong

注意点として、shortやbyteのような小さい整数型の場合、演算結果はint型に昇格されて返されます。

これはC#の整数演算の仕様によるもので、型の安全性を保つためです。

数値範囲の制限

剰余演算の結果は、除数の絶対値よりも小さい値になります。

ただし、C#の%演算子は被除数の符号を保持するため、結果の符号は被除数と同じになります。

例えば、

int result1 = 7 % 3;   // 結果は1
int result2 = -7 % 3;  // 結果は-1

このように、剰余の絶対値は常に除数の絶対値より小さくなりますが、符号は被除数に従います。

また、除数が0の場合はDivideByZeroExceptionがスローされるため、除数が0でないことを事前にチェックする必要があります。

浮動小数点数での剰余

%演算子は整数型だけでなく、floatやdoubleなどの浮動小数点数にも使えます。

ただし、浮動小数点数の剰余は厳密な数学的剰余とは異なり、丸め誤差の影響を受けることがあります。

浮動小数点数の剰余を計算する場合は、Math.IEEERemainderメソッドを使うことも検討してください。

こちらはIEEE 754標準に準拠した剰余計算を行います。

以上がC#におけるmod関数の役割を果たす%演算子の基本的な使い方と評価順序、戻り値の型や数値範囲の説明です。

対応データ型とキャスト

整数型ごとの動作(int, long ほか)

C#の%演算子は整数型に対して幅広く対応していますが、型ごとに動作の細かい違いがあります。

代表的な整数型であるint、long、short、byte、uint、ulongなどでの挙動を理解しておくことが重要です。

まず、int型は最も一般的に使われる整数型で、32ビット符号付き整数です。

int同士の剰余演算はそのままint型で結果が返ります。

int a = 10;
int b = 3;
int result = a % b; // 結果は1
Console.WriteLine(result);

long型は64ビット符号付き整数で、より大きな数値範囲を扱えます。

long同士の剰余演算もlong型で結果が返ります。

long a = 10000000000;
long b = 3;
long result = a % b; // 結果は1
Console.WriteLine(result);

shortやbyteのような小さい整数型は、演算時にint型に昇格されます。

これはC#の仕様で、算術演算はint型以上で行われるためです。

したがって、shortやbyte同士の剰余演算でも結果はint型になります。

short a = 10;
short b = 3;
int result = a % b; // 結果は1、型はint
Console.WriteLine(result);

符号なし整数型のuintやulongも剰余演算に対応しています。

uint同士の剰余はuint型、ulong同士の剰余はulong型で返されます。

uint a = 10;
uint b = 3;
uint result = a % b; // 結果は1
Console.WriteLine(result);

符号なし型の場合、剰余の結果は常に0以上になります。

符号付き型と異なり、負の値は扱えません。

キャストの注意点

異なる整数型同士で剰余演算を行う場合は、暗黙的な型変換が行われるか、明示的なキャストが必要です。

例えば、intとlongの剰余演算はできません。

int a = 10;
long b = 3;
// long result = a % b; // コンパイルエラー
long result = a % (int)b; // 明示的にキャストすればOK

型の不一致によるエラーを防ぐため、演算前に型を揃えることが大切です。

decimal型での剰余

decimal型は高精度な小数点数を扱うための型で、金融計算などでよく使われます。

%演算子はdecimal型にも対応しており、小数点以下の剰余を計算できます。

decimal a = 10.5m;
decimal b = 3.2m;
decimal result = a % b; // 結果は1.9
Console.WriteLine(result);

1.9

この例では、10.5を3.2で割った余りが1.9として計算されます。

decimal型の剰余は整数型の剰余と同様に、被除数の符号を結果に保持します。

decimal型の剰余は浮動小数点数の%演算子とは異なり、より高精度で誤差が少ない計算が可能です。

ただし、decimal型は計算コストが高いため、パフォーマンスが重要な場面では注意が必要です。

BigInteger の活用

BigIntegerはSystem.Numerics名前空間にある任意精度整数型で、非常に大きな整数の計算に使われます。

BigInteger型も剰余演算に対応しており、%演算子を使って余りを求められます。

using System;
using System.Numerics;
class Program
{
    static void Main()
    {
        BigInteger bigA = BigInteger.Parse("123456789012345678901234567890");
        BigInteger bigB = new BigInteger(97);
        BigInteger result = bigA % bigB;
        Console.WriteLine(result);
    }
}

この例では、非常に大きな数値を97で割った余りを計算しています。

BigIntegerは整数の桁数に制限がないため、通常の整数型では扱えない巨大な数値の剰余計算に適しています。

BigIntegerの剰余演算も被除数の符号を保持します。

負のBigIntegerに対しても同様の挙動です。

BigInteger bigA = new BigInteger(-123456789);
BigInteger bigB = new BigInteger(100);
BigInteger result = bigA % bigB; // 結果は-89
Console.WriteLine(result);

-89

BigIntegerを使う場合は、System.Numericsの参照を追加し、名前空間をインポートする必要があります。

大きな数値の剰余計算や、整数の範囲を超える計算が必要な場合に活用してください。

負の数を含む計算の挙動

符号保持のルール

C#の%演算子は、剰余の符号に関して独特のルールを持っています。

具体的には、剰余の符号は被除数(割られる数)の符号と一致します。

これは、商の符号に関係なく、余りの符号が被除数の符号に従うということです。

例えば、正の数を正の数で割った場合は当然剰余も正の値になります。

int a = 7;
int b = 3;
int result = a % b; // 7 % 3 = 1
Console.WriteLine(result);

一方、被除数が負の場合は剰余も負になります。

int a = -7;
int b = 3;
int result = a % b; // -7 % 3 = -1
Console.WriteLine(result);

-1

このように、剰余の符号は被除数の符号に合わせて決まるため、剰余の値は常に被除数の符号を持ちます。

除数の符号は剰余の符号に影響しません。

int a = 7;
int b = -3;
int result = a % b; // 7 % -3 = 1
Console.WriteLine(result);

この例では、除数が負でも剰余は正のままです。

数学的モジュロとの違い

数学での「モジュロ演算(mod)」は、剰余の符号が常に非負(0以上)になることが一般的です。

つまり、数学的なモジュロは剰余が0から除数の絶対値未満の範囲に収まるように定義されています。

一方、C#の%演算子は「剰余演算子」であり、数学的なモジュロとは異なります。

C#の剰余演算は被除数の符号を保持するため、負の剰余が発生することがあります。

例えば、数学的モジュロでは次のように計算されます。

-7 mod 3 = 2 (0 ≤ 2 < 3)

しかし、C#の%演算子では

-7 % 3 = -1

となり、剰余が負の値になります。

この違いは、プログラミング言語間での剰余演算の実装の違いに起因します。

数学的モジュロを実現したい場合は、C#で独自に計算式を用意する必要があります。

よくある誤解と回避策

誤解1：%演算子は常に非負の剰余を返す

多くのプログラマーが%演算子は剰余を計算し、結果は常に0以上になると誤解しがちです。

しかし、C#では被除数の符号が剰余の符号に影響するため、負の剰余が返ることがあります。

誤解2：剰余の符号は除数の符号に依存する

実際には剰余の符号は被除数の符号に依存し、除数の符号は影響しません。

除数が負でも剰余の符号は変わりません。

回避策：数学的モジュロを実装する方法

数学的モジュロのように剰余を常に非負にしたい場合は、以下のような拡張メソッドを使うと便利です。

public static int Mod(int a, int b)
{
    int result = a % b;
    if (result < 0)
    {
        result += Math.Abs(b);
    }
    return result;
}

このメソッドは、a % bの結果が負の場合に除数の絶対値を足して非負に変換します。

int a = -7;
int b = 3;
int result = Mod(a, b); // 結果は2
Console.WriteLine(result);

このように、剰余が常に0以上になるため、数学的モジュロの定義に沿った結果が得られます。

C#の%演算子は剰余の符号を被除数に合わせる
数学的モジュロとは異なり、負の剰余が返ることがある
剰余の符号は除数の符号に依存しない
必要に応じて独自のモジュロ関数を実装して非負の剰余を得ることができる

これらのポイントを理解しておくことで、負の数を含む剰余計算での誤解やバグを防げます。

浮動小数点数の剰余

double・float と % 演算子

C#では、doubleやfloatといった浮動小数点数型に対しても%演算子を使って剰余を計算できます。

整数型の剰余と同様に、a % bはaをbで割った余りを返しますが、浮動小数点数の場合は計算の性質や結果の挙動に注意が必要です。

double a = 5.5;
double b = 2.0;
double result = a % b; // 5.5 % 2.0 = 1.5
Console.WriteLine(result);

1.5

この例では、5.5を2.0で割った余りが1.5として計算されます。

float型でも同様に使えます。

float x = 5.5f;
float y = 2.0f;
float result = x % y; // 1.5f
Console.WriteLine(result);

1.5

ただし、浮動小数点数の剰余は丸め誤差や計算誤差の影響を受けやすいため、結果が厳密に期待通りにならない場合があります。

特に非常に小さい値や非常に大きい値を扱う場合は注意が必要です。

Math.IEEERemainder の特徴

C#のMathクラスにはIEEERemainderメソッドがあり、これは浮動小数点数の剰余を計算する別の方法です。

Math.IEEERemainderはIEEE 754標準に準拠した剰余計算を行い、%演算子とは異なる結果を返すことがあります。

double a = 5.5;
double b = 2.0;
double result1 = a % b;                 // 1.5
double result2 = Math.IEEERemainder(a, b); // -0.5
Console.WriteLine($"% 演算子の結果: {result1}");
Console.WriteLine($"IEEERemainderの結果: {result2}");

% 演算子の結果: 1.5
IEEERemainderの結果: -0.5

Math.IEEERemainderは、a - (b * n)の計算を行います。

ここでnはa / bに最も近い整数(四捨五入)です。

これにより、剰余の値は-b/2からb/2の範囲に収まります。

一方、%演算子はa - (b * trunc(a / b))の計算で、truncは小数点以下を切り捨てる関数です。

これにより剰余は常に0からbの範囲に収まります。

IEEE754 視点での差異

IEEE 754は浮動小数点演算の国際標準規格であり、Math.IEEERemainderはこの規格に準拠した剰余計算を行います。

これに対し、%演算子は整数の剰余演算の拡張として実装されており、IEEE 754の剰余定義とは異なります。

IEEE 754の剰余は「最も近い整数倍の除数を引いた結果」と定義されており、結果の範囲は-b/2からb/2の間に収まります。

これにより、剰余の値は正負両方の範囲に分布し、符号は被除数や除数の符号に依存しません。

一方、%演算子は剰余の符号を被除数に合わせるため、結果は常に0からbの範囲(除数が正の場合)に収まります。

この違いは、数値計算の目的やアルゴリズムによって使い分けが必要です。

例えば、周期的なパターンの計算や配列の循環アクセスには%演算子が適していますが、物理シミュレーションや信号処理などでIEEE 754準拠の剰余が必要な場合はMath.IEEERemainderを使うと良いでしょう。

以上のように、浮動小数点数の剰余計算では%演算子とMath.IEEERemainderの違いを理解し、用途に応じて適切な方法を選択することが重要です。

よく使うユースケース

配列・リストの循環アクセス

配列やリストの要素を順番にアクセスしていく際、インデックスが範囲外になることを防ぐために剰余演算がよく使われます。

特に、ループ処理で配列の最後まで到達した後に先頭に戻る「循環アクセス」を実現する場合に便利です。

インデックスオーバーフロー防止

例えば、配列の長さがnの場合、インデックスがn以上になると範囲外アクセスで例外が発生します。

これを防ぐために、インデックスを% nで剰余を取ることで、常に0からn-1の範囲に収められます。

string[] colors = { "Red", "Green", "Blue" };
int length = colors.Length;
for (int i = 0; i < 10; i++)
{
    int index = i % length; // 0～2の範囲に制限
    Console.WriteLine($"Index: {index}, Color: {colors[index]}");
}

Index: 0, Color: Red
Index: 1, Color: Green
Index: 2, Color: Blue
Index: 0, Color: Red
Index: 1, Color: Green
Index: 2, Color: Blue
Index: 0, Color: Red
Index: 1, Color: Green
Index: 2, Color: Blue
Index: 0, Color: Red

このように、iが増えてもindexは配列の範囲内に収まるため、例外を防ぎつつ繰り返しアクセスできます。

周期処理のタイミング制御

一定の周期で処理を繰り返す場合にも剰余演算が役立ちます。

例えば、ゲームのフレーム更新やセンサーの定期的な読み取りなど、一定間隔で特定の処理を行いたいときに、カウンターの値を剰余で制御します。

int frameCount = 0;
int interval = 60; // 60フレームごとに処理
while (true)
{
    frameCount++;
    if (frameCount % interval == 0)
    {
        Console.WriteLine("60フレーム経過しました。処理を実行します。");
    }
    if (frameCount == 180) break; // 3回実行したら終了
}

60フレーム経過しました。処理を実行します。
120フレーム経過しました。処理を実行します。
180フレーム経過しました。処理を実行します。

この例では、frameCountをintervalで割った余りが0になるタイミングで処理を実行しています。

剰余を使うことで、周期的なタイミング制御が簡単に実装できます。

暦計算と時間計測

日付や時間の計算でも剰余演算は頻繁に使われます。

例えば、曜日の計算や時間の繰り上げ処理などです。

曜日は7日周期なので、日数を7で割った剰余を使って曜日を求めることができます。

int dayNumber = 10; // 10日目
string[] weekdays = { "日", "月", "火", "水", "木", "金", "土" };
int weekdayIndex = dayNumber % 7;
Console.WriteLine($"10日目の曜日は {weekdays[weekdayIndex]} です。");

10日目の曜日は 火 です。

また、時間の計算で24時間制を扱う場合も、時間数を24で割った剰余を使って繰り上げを防ぎます。

int hour = 25;
int normalizedHour = hour % 24;
Console.WriteLine($"正規化された時間は {normalizedHour} 時です。");

正規化された時間は 1 時です。

このように、剰余演算は時間や日付の周期的な計算に欠かせません。

ハッシュ関数やテーブル分割

ハッシュテーブルやデータベースのパーティショニングなどで、データを一定の範囲に分割する際に剰余演算が使われます。

ハッシュ値をテーブルのサイズで割った余りをインデックスとして利用し、データの格納先を決定します。

int hashValue = "example".GetHashCode();
int tableSize = 16;
int index = Math.Abs(hashValue) % tableSize;
Console.WriteLine($"ハッシュテーブルのインデックス: {index}");

ハッシュテーブルのインデックス: 5

ここでは、文字列のハッシュコードをテーブルサイズで割った余りを使い、0から15の範囲のインデックスを得ています。

Math.Absを使って負の値を正に変換している点も重要です。

乱数範囲の制限

乱数生成で特定の範囲に値を制限したい場合にも剰余演算が使われます。

例えば、0からn-1までの整数乱数を生成する際に、乱数の大きな値をnで割った余りを使う方法です。

Random rand = new Random();
int n = 10;
int randomValue = rand.Next() % n;
Console.WriteLine($"0から{n - 1}までの乱数: {randomValue}");

0から9までの乱数: 7

ただし、Random.Next(int maxValue)メソッドを使えば剰余を使わずに範囲指定が可能なので、通常はこちらを使うほうが良いです。

int randomValue2 = rand.Next(n);
Console.WriteLine($"0から{n - 1}までの乱数: {randomValue2}");

0から9までの乱数: 3

剰余を使う方法は、独自の乱数生成器や特別な用途で範囲制限が必要な場合に活用されます。

これらのユースケースは、剰余演算がプログラミングで非常に多用途に使われていることを示しています。

特に配列の循環アクセスや周期処理の制御は日常的に役立つテクニックです。

エラーと例外への備え

除数 0 のときの挙動

C#における剰余演算で最も注意すべきエラーの一つが、除数が0の場合の挙動です。

%演算子で除数に0を指定すると、実行時にDivideByZeroExceptionがスローされ、プログラムが異常終了する可能性があります。

int a = 10;
int b = 0;
int result = a % b; // ここで例外が発生する

このコードを実行すると、以下のような例外が発生します。

System.DivideByZeroException: Attempted to divide by zero.

この例外は整数型の剰余演算で発生します。

浮動小数点数floatやdoubleの場合は異なり、除数が0でも例外は発生せず、結果はNaN(Not a Number)やInfinityになることがあります。

double a = 10.0;
double b = 0.0;
double result = a % b; // 結果はNaN
Console.WriteLine(result);

NaN

除数0の例外を防ぐ方法

除数が0になる可能性がある場合は、事前にチェックして例外を防ぐことが重要です。

int a = 10;
int b = 0;
if (b != 0)
{
    int result = a % b;
    Console.WriteLine(result);
}
else
{
    Console.WriteLine("除数が0のため計算できません。");
}

このように条件分岐で除数をチェックすることで、例外の発生を未然に防げます。

checked コンテキストとオーバーフロー

C#では整数演算においてオーバーフローが発生した場合、デフォルトでは例外はスローされず、値がラップアラウンド(循環)します。

剰余演算でも同様です。

int max = int.MaxValue; // 2147483647
int result = max + 1;   // オーバーフローして最小値にラップ
Console.WriteLine(result);

-2147483648

このように、オーバーフローが発生しても例外は発生せず、値が循環してしまいます。

剰余演算でも同様に、オーバーフローが起きる可能性があります。

checked コンテキストの利用

checkedキーワードを使うと、オーバーフローが発生した際にOverflowExceptionがスローされるようになります。

これにより、意図しない値の循環を防ぎ、バグの早期発見に役立ちます。

checked
{
    int max = int.MaxValue;
    int result = max + 1; // ここで例外が発生する
    Console.WriteLine(result);
}

このコードを実行すると、以下の例外が発生します。

System.OverflowException: Arithmetic operation resulted in an overflow.

剰余演算でも同様にcheckedを使えます。

checked
{
    int a = int.MinValue;
    int b = -1;
    int result = a % b; // オーバーフロー例外が発生する可能性あり
    Console.WriteLine(result);
}

ただし、剰余演算でオーバーフローが起きるケースは非常に稀ですが、int.MinValue % -1のような特定の組み合わせで発生します。

unchecked コンテキスト

逆に、uncheckedを使うとオーバーフロー時に例外をスローせず、値がラップアラウンドする動作を明示的に指定できます。

unchecked
{
    int max = int.MaxValue;
    int result = max + 1; // ラップアラウンドして最小値になる
    Console.WriteLine(result);
}

除数が0の剰余演算はDivideByZeroExceptionをスローするため、事前に除数チェックが必要
浮動小数点数の剰余は除数0でも例外は発生せず、NaNやInfinityになる
整数演算のオーバーフローはデフォルトで例外をスローしないため、checkedを使って検出可能
剰余演算でも特定の条件でオーバーフローが起きることがあるため、必要に応じてcheckedを利用する

これらのポイントを押さえて、剰余演算におけるエラーや例外を適切に扱いましょう。

パフォーマンスの考察

コンパイラ最適化の概要

C#のコンパイラやJIT(Just-In-Time)コンパイラは、%演算子を含む算術演算に対して様々な最適化を行います。

特に剰余演算はCPUの命令セットに直接対応しているため、基本的には高速に実行されます。

例えば、剰余演算が定数除数に対して行われる場合、コンパイラは除算や剰余の計算を乗算やシフト演算に置き換えることがあります。

これにより、実行時の負荷が軽減され、パフォーマンスが向上します。

ただし、除数が変数の場合は通常の除算命令が使われるため、計算コストは高めです。

CPUによっては除算命令が比較的遅いため、頻繁に剰余演算を行う場合は注意が必要です。

ビット演算による代替手法

剰余演算のパフォーマンスをさらに向上させたい場合、特に除数が2のべき乗である場合は、ビット演算を使った代替手法が有効です。

2のべき乗で割った剰余は、ビットマスクを使って高速に計算できます。

具体的には、n % 2^kはn & (2^k - 1)と同じ結果になります。

int n = 29;
int divisor = 8; // 2^3
int remainder = n & (divisor - 1); // 29 & 7 = 5
Console.WriteLine(remainder);

この方法は除算や剰余演算よりも高速に動作し、特にループ内やリアルタイム処理で効果的です。

ただし、除数が2のべき乗であることが前提なので、一般的な剰余計算には使えません。

ベンチマークの傾向

実際のベンチマークでは、%演算子のパフォーマンスはCPUの種類や実行環境によって異なりますが、一般的に整数の剰余演算は比較的コストが高い演算の一つです。

除数が定数の場合、コンパイラ最適化により高速化されることが多い
除数が変数の場合、除算命令が使われるため遅くなる傾向がある
ビット演算による代替は2のべき乗除数に限定されるが、非常に高速
浮動小数点数の剰余は整数よりもさらに計算コストが高い

以下は簡単なベンチマーク例です。

using System;
using System.Diagnostics;
class Program
{
    static void Main()
    {
        const int iterations = 100_000_000;
        int sum = 0;
        int divisor = 3;
        var sw = Stopwatch.StartNew();
        for (int i = 0; i < iterations; i++)
        {
            sum += i % divisor;
        }
        sw.Stop();
        Console.WriteLine($"% 演算子の時間: {sw.ElapsedMilliseconds} ms");
        sum = 0;
        sw.Restart();
        int mask = divisor - 1; // 3は2のべき乗ではないので参考例
        for (int i = 0; i < iterations; i++)
        {
            sum += i & mask; // 正確な剰余ではないが参考
        }
        sw.Stop();
        Console.WriteLine($"ビット演算の時間: {sw.ElapsedMilliseconds} ms");
    }
}

この例では、divisorが3なのでビット演算は正確な剰余ではありませんが、2のべき乗の場合はビット演算が大幅に高速になることがわかっています。

パフォーマンスを重視する場合は、剰余演算の除数が2のべき乗かどうかを確認し、可能ならビット演算に置き換えることを検討してください。

また、頻繁に剰余演算を行う処理では、除数を定数に固定してコンパイラの最適化を活用するのも効果的です。

独自の Modulo 実装例

正の余りを保証する拡張メソッド

C#の%演算子は剰余の符号が被除数に依存するため、負の数を扱う場合に負の余りが返ることがあります。

数学的なモジュロ演算のように、常に正の余りを返したい場合は独自にメソッドを実装するのが一般的です。

以下は、整数型に対して正の余りを保証する拡張メソッドの例です。

public static class ModExtensions
{
    /// <summary>
    /// 剰余を計算し、常に0以上の結果を返す拡張メソッド
    /// </summary>
    /// <param name="a">被除数</param>
    /// <param name="b">除数(0以外)</param>
    /// <returns>0以上の剰余</returns>
    public static int Mod(this int a, int b)
    {
        if (b == 0)
            throw new DivideByZeroException("除数は0以外でなければなりません。");
        int result = a % b;
        if (result < 0)
            result += Math.Abs(b);
        return result;
    }
}

このメソッドは、a % bの結果が負の場合に除数の絶対値を足して正の値に変換します。

使い方は以下の通りです。

class Program
{
    static void Main()
    {
        int a = -7;
        int b = 3;
        int result = a.Mod(b);
        Console.WriteLine(result); // 出力: 2
    }
}

このように、負の被除数でも常に0以上の剰余が得られます。

拡張メソッドとして定義しているため、int型の変数に対して自然な形で呼び出せるのが利点です。

ジェネリック化の設計ポイント

剰余演算の拡張メソッドを整数型以外にも対応させたい場合、ジェネリック化を検討します。

しかし、C#のジェネリックは算術演算子を直接サポートしていないため、工夫が必要です。

制約と課題

ジェネリック型パラメータに対して%演算子を直接使えない
IConvertibleやIComparableなどのインターフェースでは演算子は定義されていない
動的型付けやdynamicを使う方法もあるが、パフォーマンスや安全性に影響がある

実装例：dynamicを使ったジェネリックメソッド

public static class ModExtensions
{
    public static T Mod<T>(this T a, T b) where T : struct
    {
        if (b.Equals(default(T)))
            throw new DivideByZeroException("除数は0以外でなければなりません。");
        dynamic da = a;
        dynamic db = b;
        dynamic result = da % db;
        if (result < 0)
            result += (db < 0) ? -db : db;
        return result;
    }
}

この方法はdynamicを使うことで演算子を動的に解決しますが、実行時のオーバーヘッドが発生します。

class Program
{
    static void Main()
    {
        int a = -7;
        int b = 3;
        Console.WriteLine(a.Mod(b)); // 2
        long x = -10L;
        long y = 4L;
        Console.WriteLine(x.Mod(y)); // 2
    }
}

2
2

パフォーマンス重視の場合

パフォーマンスを重視する場合は、型ごとにオーバーロードを用意するか、System.NumericsのBigIntegerなど特定の型に限定して実装するのが現実的です。

ジェネリックで剰余演算を扱うにはdynamicを使うか、型ごとに実装を分ける必要がある
dynamicは簡単だが実行時コストがあるため、用途に応じて使い分ける
拡張メソッドとして実装すると使いやすく、コードの可読性も向上する

これらのポイントを踏まえて、用途に合った独自のModulo関数を設計してください。

他言語との比較

C/C++ の % と違い

CやC++における%演算子は、C#の%演算子と似ていますが、負の数に対する挙動に微妙な違いがあります。

C/C++の%は「剰余演算子」として定義されており、被除数の符号を保持する点はC#と同じです。

例えば、C++での計算例：

int a = -7;
int b = 3;
int result = a % b; // 結果は-1

この結果はC#の-7 % 3と同じく-1になります。

ただし、C++の標準規格(C++11以降)では、商の切り捨て方向が明確に定義されており、剰余の符号は被除数の符号と一致します。

古いC言語の実装では符号の扱いが環境依存だったこともありますが、現在は標準化されています。

一方で、C/C++では浮動小数点数に対して%演算子は使えません。

浮動小数点数の剰余はfmod関数(<cmath>ヘッダ)を使います。

#include <cmath>
double result = fmod(5.5, 2.0); // 結果は1.5

Python の挙動

Pythonの%演算子はC#やC++とは異なり、数学的モジュロ演算の定義に従っています。

つまり、剰余は常に非負で、除数の符号に関係なく結果は0以上になります。

print(-7 % 3)  # 出力: 2
print(7 % -3)  # 出力: -2

Pythonでは、剰余の符号は除数の符号に合わせて決まります。

被除数が負でも剰余は非負になるわけではなく、除数の符号に依存します。

この挙動は数学的モジュロの定義に近く、負の数を含む計算で予測しやすい結果を得られます。

また、Pythonのdivmod関数は商と剰余を同時に返し、剰余の符号ルールも同様です。

JavaScript の remainder

JavaScriptの%演算子は剰余演算子として動作し、C#と同様に被除数の符号を剰余の符号として保持します。

console.log(7 % 3);   // 1
console.log(-7 % 3);  // -1
console.log(7 % -3);  // 1

このため、負の被除数に対しては負の剰余が返ります。

JavaScriptでは整数型と浮動小数点型の区別がなく、すべてNumber型(IEEE 754準拠の64ビット浮動小数点数)として扱われます。

浮動小数点数の剰余も%演算子で計算できますが、丸め誤差に注意が必要です。

JavaScriptにはMathオブジェクトにIEEERemainderに相当する関数はありません。

SQL における MOD 関数

SQLでは、剰余を計算するためにMOD関数が用意されています。

多くのデータベースでサポートされており、構文は以下のようになります。

SELECT MOD(-7, 3); -- 結果は2(多くのDBで数学的モジュロ)

SQLのMOD関数は数学的モジュロの定義に従い、剰余は常に非負になります。

被除数が負でも結果は0以上となるため、C#の%演算子とは異なります。

ただし、データベース製品によって挙動が異なる場合があるため、使用するDBMSのドキュメントを確認することが重要です。

例えば、OracleやPostgreSQLではMODは数学的モジュロとして動作しますが、SQL Serverでは%演算子が使われ、C#と同様の符号ルールを持ちます。

これらの違いを理解しておくことで、異なる言語間での剰余計算の結果の違いに戸惑わず、適切にコードを移植・連携できます。

コーディングスタイルと可読性

名前付けとマジックナンバー排除

剰余演算を含むコードを書く際には、変数名や定数の名前付けに注意することで、コードの可読性と保守性が大きく向上します。

特に、剰余の除数や周期を表す数値は「マジックナンバー」として直接コードに埋め込むのではなく、意味のある名前を付けた定数として管理することが推奨されます。

例えば、以下のように直接数値を使うコードは理解しづらくなります。

int index = i % 7;

この場合、7が何を意味するのかがコードを読むだけではわかりません。

これを改善するには、定数に名前を付けて使います。

const int DaysInWeek = 7;
int index = i % DaysInWeek;

こうすることで、DaysInWeekが7日間の周期を表していることが明確になり、コードの意図が伝わりやすくなります。

また、変数名も意味のある名前を付けることが重要です。

例えば、剰余の結果を格納する変数をremainderやmodResultなどと命名すると、何を表しているのかが一目でわかります。

int remainder = value % divisor;

このように、名前付けに気を配ることで、コードの読み手が理解しやすくなり、バグの発見や修正もスムーズになります。

品質確認のポイント

剰余演算を含むコードの品質を保つためには、以下のポイントを意識して確認すると良いでしょう。

除数の妥当性チェック

除数が0になっていないかを必ずチェックし、DivideByZeroExceptionの発生を防ぐ。

特に外部入力や計算結果を除数に使う場合は注意が必要です。

負の数の扱いの明確化

剰余の符号ルールを理解し、負の数が入力される可能性がある場合は、期待する挙動に合うように処理を設計します。

必要に応じて正の余りを保証する独自メソッドを使います。

マジックナンバーの排除

除数や周期を表す数値は定数化し、意味のある名前を付けることでコードの意図を明確にします。

単体テストの実施

剰余演算を含むロジックは、特に負の数や境界値(0、1、最大値・最小値など)を含むテストケースを用意し、期待通りの結果が得られるかを検証します。

例外処理の実装

除数0やオーバーフローなどの例外が発生する可能性がある場合は、適切に例外処理を行い、プログラムの安定性を確保します。

コメントやドキュメントの充実

剰余演算の目的や特別な処理(例えば正の余りを保証する理由など)について、コメントやドキュメントで説明を加えると、将来的なメンテナンスが楽になります。

これらのポイントを踏まえてコードを書くことで、剰余演算を含む処理の品質と可読性を高め、バグの発生を抑制できます。

まとめ

この記事では、C#における%演算子とmod関数の基本的な使い方から、負の数の挙動や浮動小数点数での剰余計算、よく使われるユースケースまで幅広く解説しました。

特に負の数の符号ルールや他言語との違い、エラー対策、パフォーマンス面の注意点も詳しく紹介しています。

独自の正の余りを保証する拡張メソッドやコーディングスタイルのポイントも押さえ、実践的に役立つ内容となっています。