Как представляются десятичные дроби? -- Числа с плавающей запятой и IEEE 754

В этой лекции вы поймёте: как представляются десятичные дроби в мире, где есть только 0 и 1, и почему у чисел с плавающей запятой возникают ошибки точности.


Бытовая аналогия: экспоненциальная запись

Вы наверняка видели экспоненциальную запись на уроках физики:

Скорость света = 3.0 x 108m/s, масса электрона = 9.1 x 10-31 kg.

Этот метод позволяет представлять очень большие или очень маленькие числа с помощью очень небольшого количества цифр.

Компьютеры используют ровно ту же идею для представления десятичных дробей--Двоичная экспоненциальная запись。

Любую двоичную дробь можно записать в виде:

1.xxxxxxxxxx x 2yyyyy

В этой форме нужно хранить только три вещи:

  • знак: положительный или отрицательный?
  • мантисса(xxxxxxxxxx): часть значащих цифр
  • Экспонента(yyyyy): положение десятичной точки

Стандарт IEEE 754 упаковывает эти три вещи в 32 бита в фиксированном формате.


Трёхсегментная структура IEEE 754 одинарной точности

32 бита (float одинарной точности) точно разделены на три сегмента:

Бит знака 0 1 бит
Экспонента 00000000 8 бит
Биты мантиссы: мантисса (дробная часть) 00000000000000000000000 23 бита
Бит знака (1 бит)
Биты экспоненты (8 бит)
Биты мантиссы (23 бита)

Первая часть: бит знака (1 бит)

Самый простой сегмент.

0представляет положительные числа,1представляет отрицательные числа.

Второй сегмент: биты экспоненты (8 бит)

Экспонента определяет положение десятичной точки (отсюда и происходит название "плавающая точка" -- десятичная точка может "плавать").

Но экспонента хранится не напрямую; вместо этого хранится "фактическая экспонента + 127".

Это число 127 называетсясмещением (Bias)。

Зачем добавлять смещение?

Поскольку 8 бит могут представить только 0~255 (без знака), но фактическая экспонента должна быть отрицательной (чтобы представлять числа меньше 1).

После добавления смещения 127:

  • Хранимое значение 127 соответствует фактической экспоненте 0 (127 - 127 = 0)
  • Хранимое значение 0 соответствует фактической экспоненте -127
  • Хранимое значение 255 соответствует фактической экспоненте +128

Третий сегмент: биты мантиссы (23 бита)

Мантисса хранит часть «xxxxx» из «1.xxxxx», опуская ведущую 1.

Поскольку в двоичной научной нотации нормализованная форма всегда имеет вид 1.xxx, ведущую 1 не нужно хранить.

Это хитроумно экономит дополнительный 1 бит точности.

Ключ к пониманию структуры из трёх сегментов: число с плавающей точкой = (-1)^знак× 1.мантисса × 2(Экспонента-127)В этом вся суть IEEE 754.


Интерактивная демонстрация: разбор 32-битного числа с плавающей точкой

Введите число с плавающей точкой и посмотрите его структуру из трёх сегментов в формате IEEE 754 одинарной точности.

Сегментированная полоса покажет, каким битам соответствует каждый из трёх сегментов.

Анализатор IEEE 754 одинарной точности

Входное число с плавающей запятой:

Попробуйте ввести 0.1 и посмотрите на мантиссу.

Двоичная мантисса числа 0.1 — бесконечно повторяющаяся дробь; 23 бита совершенно недостаточно для её хранения.

Это приводит к известному явлению в вычислениях.


Почему 0.1 + 0.2 не равно 0.3

Если запустить это в Python или JavaScript0.1 + 0.2 == 0.3, результат —False。

Это не ошибка, а неизбежное следствие представления чисел с плавающей запятой.

Причина очень проста:0.1 невозможно точно представить в двоичном виде。

Точно так же, как в десятичной системе, 1/3 = 0.33333... — это бесконечная периодическая десятичная дробь.

В двоичной системе 0.1 (десятичное) = 0.000110011001100110011... (двоичное), что также является бесконечной периодической дробью.

IEEE 754 имеет только 23 бита мантиссы для хранения этой бесконечной периодической десятичной дроби.

Часть за пределами 23 бит может быть только усечена (округлена), что приводит к ошибке округления.

Значение, фактически хранимое для 0.1 в float32, приблизительно равно 0.100000001490116119384765625.

Значение, фактически хранимое для 0.2 в float32, приблизительно равно 0.20000000298023223876953125.

После сложения этих двух значений и усечения результат не равен ровно 0.3.

При вычислении сумм необходимо избегать чисел с плавающей запятой

В сценариях, связанных с деньгами, следует использовать целые числа (в единицах "центов") или специальный тип Decimal.

PythonDecimalJavaBigDecimalC#'sdecimalвсе они предназначены для этого.

Если вы храните деньги с помощью чисел с плавающей запятой, к тому времени, когда вы обнаружите, что накопленная ошибка 0.01 превратилась в 0.010000000000000002, семена проблемы были посеяны давным-давно.


Диапазон чисел с плавающей запятой и специальные значения

IEEE 754 резервирует несколько специальных комбинаций для экспоненты и мантиссы:

КатегорияЗнаковый битЭкспонента (хранение)мантиссаЗначение
ноль0 или 10 (все нули)Все нули+0 или -0
Субнормальное число0 или 10 (все нули)Не все нулиЗначения, очень близкие к 0
Нормализованное число0 или 11 ~ 254AnyНормальные числа с плавающей запятой
Бесконечность0 или 1255 (все единицы)Все нули+Бесконечность или -Бесконечность
NaNAny255 (все единицы)Не все нулиНечисловые значения (например, 0/0)

Приблизительный диапазон числа с плавающей запятой одинарной точности (32 бита):

  • Максимальное положительное значение: приблизительно 3.4 x 1038
  • Наименьшее положительное значение (нормализованное): приблизительно 1.2 x 10-38
  • Наименьшее положительное значение (денормализованное): приблизительно 1.4 x 10-45
  • Эффективная точность: приблизительно 7 значащих десятичных цифр

Число с плавающей запятой двойной точности double (64 бита) имеет больший диапазон и более высокую точность:

  • 11-битная экспонента (смещение 1023)
  • 52-битная мантисса
  • Эффективная точность: примерно 15~16 значащих десятичных цифр

Три случая потери точности чисел с плавающей запятой

Случай 1: ошибка преобразования десятичного числа в двоичное

Например, рассмотренный ранее пример с 0.1.

Любое десятичное число, которое «чисто» в десятичной системе, может бесконечно повторяться в двоичной.

Только дроби, знаменатель которых является степенью 2 (например, 0.5, 0.25, 0.125), могут быть точно представлены в двоичной системе.

Случай 2: прибавление малого числа к большому

Точность чисел с плавающей запятой распределена неравномерно -- чем больше значение, тем больше наименьшая различимая разность.

Например, 16777216.0 + 1.0 = 16777216.0 (в float32 результат остаётся неизменным).

Потому что 32-битное число с плавающей запятой может точно представить только около 7 значащих цифр, а само число 16777216 уже занимает 8 цифр.

Изменение, возникающее при добавлении 1, попадает в диапазон точности, который мантисса не может представить, и напрямую «проглатывается».

Случай 3: вычитание двух почти равных чисел

Вычитание двух очень близких чисел с плавающей запятой может приводить ккатастрофической потере значащих цифр。

Например, 1.2345678 - 1.2345677 = 0.0000001, но фактическое вычисление может дать 0.000000099999..., результат с большой ошибкой.

Знание ограничений точности чисел с плавающей запятой нужно не для того, чтобы вы «боялись» их использовать, а для того, чтобы выбирать подходящий инструмент для подходящего сценария. Научные вычисления, рендеринг графики, машинное обучение -- чисел с плавающей запятой в этих областях вполне достаточно. Но финансы, бухгалтерский учёт, точный подсчёт -- держитесь подальше от чисел с плавающей запятой.


Демонстрация кода: секреты чисел с плавающей запятой

Пример

# Полная демонстрация проблемы точности чисел с плавающей запятой (пример демонстрации)
import struct

def float_to_ieee754_binary(num):
    Преобразовать число с плавающей запятой в трёхсегментное представление IEEE 754 одинарной точности
    # Использовать struct для упаковки числа с плавающей запятой в 4 байта (big-endian)
    packed = struct.pack('>f', num)
    # Преобразовать в 32-битную двоичную строку
    bits = ''.join(f'{b:08b}' for b in packed)

    sign = bits[0]
    exponent = bits[1:9]
    mantissa = bits[9:32]

    exp_stored = int(exponent, 2)
    exp_actual = exp_stored - 127

    # Вычислить десятичное значение мантиссы
    frac = 0
    for i, bit in enumerate(mantissa):
        if bit == '1':
            frac += 2 ** -(i + 1)

    value = (-1 if sign == '1' else 1) * (1 + frac) * (2 ** exp_actual)

    return {
        'bits': bits,
        'sign': sign,
        'exponent': exponent,
        'mantissa': mantissa,
        'exp_stored': exp_stored,
        'exp_actual': exp_actual,
        'fraction': frac,
        'reconstructed': value
    }

# =============================================
# Демонстрация 1: Сравнение представления 0.5 и 0.1
# =============================================
print("=" * 60)
print("Демонстрация 1: Почему 0.5 точно, а 0.1 — нет")
print("=" * 60)

for num in [0.5, 0.1]:
    r = float_to_ieee754_binary(num)
    print(f"\nЧисло с плавающей запятой: {num}")
    print(fБит знака: {r['sign']} ({'положительный' if r['sign'] == '0' else 'отрицательный'}))
    print(f" Биты экспоненты: {r['exponent']} (Сохранённое={r['exp_stored']}, фактическое={r['exp_actual']})")
    print(fБиты мантиссы: {r['mantissa']})
    print(fФактическое сохранённое значение: {r['reconstructed']})

# =============================================
# Демонстрация 2: Классический пример 0.1 + 0.2 != 0.3
# =============================================
print("\n" + "=" * 60)
print(Демонстрация 2: 0.1 + 0.2 != 0.3)
print("=" * 60)

# Отображение с более высокой точностью
import decimal
ctx = decimal.getcontext()
ctx.prec = 50

a = decimal.Decimal(0.1)
b = decimal.Decimal(0.2)
c = decimal.Decimal(0.3)

print(f"Фактическое значение 0.1: {a}")
print(f"Фактическое значение 0.2: {b}")
print(f"Фактическое значение 0.3: {c}")
print(f"0.1 + 0.2  = {a + b}")
print(f"0.1 + 0.2 == 0.3 ? {0.1 + 0.2 == 0.3}")

# =============================================
# Демо 3: Большие числа «поглощают» маленькие числа
# =============================================
print("\n" + "=" * 60)
print("Демо 3: Большое число плюс маленькое число — маленькое поглощается")
print("=" * 60)

большие = 16777216.0
малый = 1.0
result = big + small
print(f"{big} + {small} = {result}")
print(f"Результат равен исходному числу? {result == big}")

# Показать, что это число достигает предела точности float32
print(f"\nПричина: {big} В float32 Mediumrequires {len(format(struct.unpack('>I', struct.pack('>f', big))[0], '032b')[:23])} бит мантиссы")
print(fМинимальный интервал между двумя соседними значениями float32 приблизительно равен 2^24 / 2^23 = 2.0)

# =============================================
# Демо 4: Правильные методы преобразования регистра
# =============================================
print("\n" + "=" * 60)
print("Демо 4: EXAMPLE example - Правильная обработка сумм")
print("=" * 60)

from decimal import Decimal

# Неправильный подход: использование чисел с плавающей точкой
float_total = 0.1 + 0.2
print(fОшибка (с плавающей точкой): 0.1 + 0.2 = {float_total})

# Правильный подход: используйте Decimal
decimal_total = Decimal('0.1') + Decimal('0.2')
print(f"корректное подтверждение(Decimal): Decimal('0.1') + Decimal('0.2') = {decimal_total}")

# Или используйте целые числа (в центах)
cents_total = 10 + 20  # 0.1 yuan = 10 fen, 0.2 yuan = 20 fen
print(f"правильное подтверждение(целочисленное деление): 10Divide + 20Divide = {cents_total}Divide = {cents_total/100}元")

# =============================================
# Демо 5: Особые значения чисел с плавающей запятой
# =============================================
print("\n" + "=" * 60)
print("Демо 5: Особые значения чисел с плавающей запятой")
print("=" * 60)

import math

# Бесконечность
print(f"float('inf')    = {float('inf')}")
print(f"1.0 / 0.0       = {1.0 / 0.0}")
print(f"float('inf') > 1e1000000 = {float('inf') > 1e1000000}")

# NaN
print(f"float('nan')     = {float('nan')}")
print(f"0.0 / 0.0        = {0.0 / 0.0}")
print(f"float('nan') == float('nan') ? {float('nan') == float('nan')}")
print(f" (NaN не равен никакому значению, включая самого себя!)")

# Проверка на NaN
print(f"math.isnan(float('nan')) = {math.isnan(float('nan'))}")

Практический совет: когда что использовать

СценарииРекомендуемый типПричина
Научные вычисления, рендеринг графикиfloat или doubleДостаточная точность, хорошая поддержка аппаратного ускорения
Расчёт финансовых суммDecimal / BigDecimalТочная десятичная арифметика, без ошибок округления
Счётчики, индексыint / longТочные целые числа, без проблем с точностью
Сравнение чисел с плавающей запятойСравнение с допускомНе используйте == напрямую; используйте abs(a-b) < epsilon
Хранение/передача денежных средствЦелые числа (в центах)Избегайте ошибок с плавающей запятой при сериализации
Другие расширения