負数の表現方法 -- 符号量表現、1の補数、2の補数

この講義で理解すること:なぜコンピュータで負数を表すのに「マイナス記号を付ける」ほど単純ではないのか、そして2の補数がどうやってすべての問題を巧みに解決するのか。


身近な例え:ホテルの階数表示

256階建てのホテルを想像してください。

自然数で階数を表すなら、0から255までしか使えません。

でも「地下128階」から「地上127階」までをすべて表したいとしたらどうでしょう?

巧妙な方法:番号128〜255を、-128〜-1として解釈し直すのです。

番号128は-128、番号255は-1、番号0はやはり0になります。

これが2の補数の核となる考え方——限られたビット範囲の中で、数値空間の「後半部分」を負数として解釈し直すことです。


最も素朴な考え方:符号量表現

負数を表す最も直接的な考え方:最上位ビットを符号ビット。

  • 最上位ビットが0 = 正数
  • 最上位ビットが1 = 負数
  • 残りのビットで絶対値を表す

8ビットを例にとると:

+5 =
0
0
0
0
0
1
0
1
符号ビット0=正
-5 =
1
0
0
0
0
1
0
1
符号ビット1=負

一見もっともらしいですよね?でも符号量表現には2つの致命的な問題があります。

問題1:+0 と -0 が同時に存在する

正の0は00000000、負の0は10000000。

同じ数値に2つの表現方法があります。

つまり比較演算(2つの数が等しいかを判定する)のたびに、ハードウェアがこの特殊ケースを余分に処理しなければなりません。

問題2:加算器では減算ができない

符号量表現で計算する5 + (-3):

5(符号量表現)
00000101
+
-3(符号量表現)
10000011
=
そのまま加算
10001000
=
結果
-8

5 + (-3) は2になるはずですが、符号量表現のまま加算すると、結果は-8になってしまいます。

つまりCPUは加算回路を再利用できず、減算専用の回路を別途設計しなければならないのです。

符号量表現の問題は次のようにまとめられます:直感的だが実用的でない。人間が読むには適しているが、回路実装には適していません。


時計からのヒント:剰余演算

先に進む前に、重要な概念を理解する必要があります——剰余演算。

時計を見てください:文字盤には12の目盛りしかありません。

10時から7時に合わせたいとき、2つの回し方があります:

方法1(反時計回り):10 - 3 =7(減算)

方法2(時計回り):10 + 9 = 19、19 mod 12 =7(加算)

「mod 12」のシステムでは、-3 と +9 は等価です(-3 + 12 = 9 だから)。

より一般的には:mod M のシステムでは、ある数を引くことは (M - その数) を足すことと同じです。。

2の補数は、この考え方を2進数に応用したものです。8ビット2進数では、法は 2^8 = 256 です。

-3 の2の補数 = 256 - 3 = 253 = 2進数11111101。

すると5 + (-3)は5 + 253 = 258。

に置き換えられます。しかし8ビットシステムでは、258は255の表現上限を超えるため、最上位ビットからの繰り上がりは「オーバーフロー」として捨てられ、残りは258 mod 256 = 2。

加算によって減算の正しい結果が得られました。


2の補数のリング図(インタラクティブデモ)

次のリング図は、4ビットの2の補数システムを直感的に示しています。

4ビットでは16個の値(0〜15)を表せますが、2の補数ではそれを -8〜+7 として解釈し直します。

スライダーを動かして数値を変えると、円環上の針の位置が変わります。

2の補数のリング図(4ビットシステム、範囲 -8 〜 +7)

0

2進数表現:0000|  符号なし解釈:0

Plotly.js ライブラリを読み込み、極座標のリング図を描画する

Plotly 2の補数のリング図(scatterpolar 極座標)

次の図は、Plotly.js の極座標を使って4ビット2の補数の16個の目盛りを示しています。青=正数領域、赤=負数領域、緑=ゼロ点です。

正数領域 (0 〜 +7)
負数領域 (-8 〜 -1)
ゼロ点
オーバーフロー点 (+7→-8)

リングの意味:

  • 時計回り = 数値の増加
  • 一周する(最大値を超える)= 起点に戻る(剰余演算の「オーバーフロー」効果)
  • 赤色領域 = 負数(2の補数での解釈)、青色領域 = 正数
  • 内側の円は符号なし解釈(0〜15)を、外側の円は2の補数での解釈(-8〜+7)を示しています。

図からわかるように、2の補数は本質的に数値空間をリング状に折りたたんだものです。。

正数が限界まで進むと(+7の後)、自然に負数(-8)になり、減算と加算はリング上では同じ方向になります。


2の補数の計算ルール

ある数の2の補数を手計算するには、同等の速い方法が2つあります:

方法1:反転+1法(標準的な方法)

  1. 絶対値に対応する2進数を書く
  2. 各ビットを反転させる(0は1に、1は0に)、1の補数が得られる
  3. 1の補数に1を加えると、2の補数が得られる

方法2:右から左へ法(暗算向きの方法)

  1. 右から左へ見て、最初の1を見つける
  2. この1より左にあるすべてのビットを反転させる
  3. この1と、それより右にあるすべてのビットはそのままにする

-20 を例にとると(8ビットシステム)、2つの方法で確認できます:

20の2進数
00010100
→
反転(1の補数)
11101011
→
1を加える(2の補数)
11101100

検証:-20 の2の補数 11101100 を符号なしとして解釈すると 236 です。

236 + 20 = 256 で、ちょうど法の値になります。これは計算が正しいことを示しています。


3つの表現方法の比較

数値符号量表現1の補数2の補数
+5000001010000010100000101
-5100001011111101011111011
+0000000000000000000000000
-01000000011111111存在しない
+127011111110111111101111111
-127111111111000000010000001
-128表現不可表現不可10000000

重要な違いは3つあります:

  1. 2の補数には -0 がない:全ビット1は -0 に使われず、-1 を表します。
  2. 2の補数は負数を1つ多く表せる:8ビット2の補数の範囲は -128 〜 +127 で、符号量表現の -127〜+127 より -128 が1つ多い。
  3. 2の補数は加算を統一する:正数を加える場合も負数を加える場合も、同じ回路を使います。

これが、Java のbyte型の範囲が -128〜127 であり、C言語のsigned charも -128〜127 である理由です。どちらも8ビットの2の補数を使っています。


インタラクティブデモ:2の補数計算機

下の欄に8ビットの範囲内の整数(-128 〜 127)を入力すると、その符号量表現、1の補数、2の補数が表示されます。

2の補数計算機(8ビット)

整数を入力:

特に注意:-128 を入力すると、2の補数は10000000。

この数の絶対値は128ですが、128は8ビットの正数範囲(0〜127)の外にあります。

つまり -128 に対応する正数の表現は存在しません——これは2の補数システムの興味深い特徴です。


2の補数のオーバーフロー

8ビット2の補数の範囲は -128〜127 です。

計算結果がこの範囲を超えると、オーバーフロー。

127 + 1
-128
が発生します(正のオーバーフロー、負の結果)
|
-128 - 1
+127
(負のオーバーフロー、正の結果)

これは先ほどのリング図を再び示しています——限界まで進むと、数値は「回り込んで戻ってくる」のです。

C/C++ において、符号付き整数のオーバーフローは未定義動作(コンパイラはそれが発生しないと仮定できる)、これは多くの奇妙なバグの根源です。


コードデモ:2の補数の完全な実装

例

# 2の補数の完全な実装と検証(サンプル デモ)

def to_twos_complement(n, bits=8):
    """整数 n を指定ビット幅の2の補数文字列に変換する"""
    if n < -2**(bits-1) or n > 2**(bits-1) - 1:
        raise ValueError(f数値 {n} は {bits} ビットの2の補数の範囲 [-{2**(bits-1)}, {2**(bits-1)-1}] を超えています)

    # モジュロ演算を利用:負数 n の符号なし対応値 = n + 2^bits
    # Pythonではビットマスクを直接使用
    mask = (1 << bits) - 1  # 例:8ビットの場合: 0xFF = 255
    unsigned_val = n & mask
    return format(unsigned_val, f'0{bits}b')

def from_twos_complement(bin_str):
    """2の補数の文字列を10進整数に変換する"""
    bits = len(bin_str)
    unsigned_val = int(bin_str, 2)

    # 最上位ビットが1(負数)の場合、2^bits を減算
    if bin_str[0] == '1':
        return unsigned_val - (1 << bits)
    else:
        return unsigned_val

def show_conversion_steps(n, bits=8):
    """n から2の補数までの詳細な手順を表示"""
    abs_bin = format(abs(n), f'0{bits}b')
    print(f数値: {n})
    print(fStep 1: 絶対値 |{n}| = {abs(n)} → 2進数 = {abs_bin})

    if n >= 0:
        print(fStep 2: 正の数の2の補数 = 符号絶対値表現 = {abs_bin})
    else:
        # ビット反転
        inverted = ''.join('1' if b == '0' else '0' for b in abs_bin)
        print(fStep 2: 反転(1の補数)= {inverted})

        # 1を加算
        carry = 1
        result_list = list(inverted)
        for i in range(bits - 1, -1, -1):
            if carry == 0:
                break
            total = int(result_list[i]) + carry
            result_list[i] = str(total % 2)
            carry = total // 2
        result = ''.join(result_list)
        print(fStep 3: 1の補数 + 1 = {result})

    comp = to_twos_complement(n, bits)
    print(f→ 最終的な2の補数: {comp})

    # 検証
    recovered = from_twos_complement(comp)
    print(f検証: 2の補数 {comp} → 解釈すると {recovered})
    print()

# テスト
print("=" * 50)
print(2の補数変換デモ(8ビットシステム))
print("=" * 50)
print()

for val in [5, -5, 0, -1, 127, -128]:
    show_conversion_steps(val)

# 2の補数の加算を検証
print("=" * 50)
print(2の補数の加算検証:減算を加算に変換)
print("=" * 50)

def twos_add(a, b, bits=8):
    """2の補数の加算(オーバーフロー処理を含む)"""
    mask = (1 << bits) - 1
    result_unsigned = (a + b) & mask
    # 符号付き結果を解釈
    if result_unsigned >= (1 << (bits - 1)):
        signed_result = result_unsigned - (1 << bits)
    else:
        signed_result = result_unsigned
    return signed_result

# 5 - 3 = 2
print(f5 + (-3) = {twos_add(5, -3)} (期待値: 2))

# 127 + 1 = -128(オーバーフロー)
print(f127 + 1 = {twos_add(127, 1)} (期待値: -128、オーバーフロー発生))

# -128 - 1 = 127(オーバーフロー)
print(f-128 + (-1) = {twos_add(-128, -1)} (期待値: 127、オーバーフロー発生))

# ゼロ同士の加算
print(f0 + 0 = {twos_add(0, 0)} (期待値: 0))

# サンプル の文字で検証:R=82, U=85 → 82 + (-85) = -3
print(f"\nサンプル テスト:R(82) + (-U(85)) = {twos_add(82, -85)} (期待値: -3))

# 2の補数の循環特性を表示
print("\n2の補数の環(4ビット簡易版、範囲 -8〜+7):)
print(数値 | 2の補数 | 符号なし)
print("-" * 30)
for n in range(-8, 8):
    comp = to_twos_complement(n, 4)
    unsig = int(comp, 2)
    print(f" {n:3d}  | {comp}   | {unsig:2d}")
その他の拡張