Арифметика в ЭВМ: числа с фиксированной и плавающей точкой

Представление чисел в ЭВМ: прямой, обратный и дополнительный коды, формат с фиксированной точкой

Для человека число — это абстрактное понятие. Для компьютера — это набор электрических сигналов, интерпретируемых как нули и единицы. Главный вызов инженерной мысли заключался не в том, как сохранить число, а в том, как эффективно выполнять арифметические операции, особенно с отрицательными и дробными числами.

Мы разберем эволюцию представления целых чисел (от прямого кода к дополнительному) и принцип работы чисел с фиксированной точкой, который широко применяется в цифровой обработке сигналов и встроенных системах.

Бит, байт и проблема знака

В основе хранения данных лежит бит — ячейка, принимающая значение 0 или 1. Группы битов образуют байты (8 бит) и машинные слова (16, 32, 64 бита).

Положительные целые числа хранятся как обычный перевод из десятичной системы в двоичную. Например, число 5 в одном байте:

$$00000101_2$$

Где индекс $_2$ указывает на двоичную систему счисления.

Для записи отрицательных чисел инженеры выделили самый старший (левый) бит под знак числа:

• 0 в старшем бите — число положительное.
• 1 в старшем бите — число отрицательное.

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

Прямой код (Sign-Magnitude)

Это наиболее интуитивный способ. Мы берем двоичную запись модуля числа и устанавливаем знаковый бит.

Рассмотрим 8-битные числа:

• $+5$ в прямом коде: 00000101
• $-5$ в прямом коде: 10000101

Формально представление описывается так:

$$[X]_{\text{пр}} = \begin{cases} 0 \cdot |X|, & X \ge 0 \\ 1 \cdot |X|, & X < 0 \end{cases}$$

Где $[X]_{\text{пр}}$ — представление числа $X$ в прямом коде, а $|X|$ — абсолютное значение (модуль) числа $X$.

Недостатки прямого кода

Несмотря на простоту, прямой код имеет два критических недостатка:

1. Два нуля. Существует «положительный ноль» (00000000) и «отрицательный ноль» (10000000). Это усложняет схемотехнику процессора, так как требуется дополнительная проверка при сравнении чисел.
2. Сложная арифметика. Сложение чисел с разными знаками нельзя выполнить простым суммированием битов. Процессору нужно сравнивать модули, определять знак результата и выполнять вычитание.

Обратный код (Ones' Complement)

Обратный код был попыткой упростить арифметику. Правило формирования:

• Положительные числа: совпадают с прямым кодом.
• Отрицательные числа: получаются путем инверсии всех битов положительного числа (0 меняется на 1, 1 на 0).

Пример для числа $-5$:

1. Берем $+5$: 00000101
2. Инвертируем все биты: 11111010

Результат 11111010 — это $-5$ в обратном коде.

Проблемы обратного кода

Хотя вычитание стало проще (его можно свести к сложению), проблема двух нулей осталась:

• $+0$: 00000000
• $-0$: 11111111 (инверсия всех нулей)

Из-за этого недостатка обратный код в современных универсальных процессорах практически не используется.

Дополнительный код (Two's Complement)

Это стандарт де-факто в современной вычислительной технике. Дополнительный код решает проблему двух нулей и позволяет выполнять вычитание через сложение без дополнительных корректировок.

Алгоритм получения

Для положительных чисел код совпадает с прямым. Для отрицательных:

1. Записать модуль числа в двоичном виде.
2. Инвертировать все биты (получить обратный код).
3. Прибавить 1 к младшему разряду.

Пример для числа $-5$:

1. $+5$: 00000101
2. Инверсия: 11111010
3. Прибавляем 1: 11111010 + 1 = 11111011

Результат: 11111011 — это $-5$ в дополнительном коде.

Математически это выражается формулой для $N$-битного числа:

$$X_{\text{доп}} = 2^N - |X|$$

Где $X_{\text{доп}}$ — представление отрицательного числа в дополнительном коде, $N$ — разрядность (количество бит), $|X|$ — модуль числа.

Преимущества дополнительного кода

1. Единственный ноль. Ноль всегда записывается как 00000000. Инверсия нулей (11111111) плюс единица дает 1 00000000, где единичка переполнения отбрасывается, оставляя чистые нули.
2. Универсальная арифметика. Процессору не нужно знать, вычитает он или складывает. Он просто складывает биты. Например, $2 + (-5)$:

$$\begin{array}{r} 00000010 \quad (+2) \\ + 11111011 \quad (-5) \\ \hline 11111101 \quad (-3) \end{array}$$

Результат 11111101 — это действительно $-3$ в дополнительном коде (инверсия даст 00000010, плюс 1 = 00000011, то есть 3).

Числа с фиксированной точкой (Fixed Point)

До сих пор мы говорили о целых числах. Но как представить дробь, например, $3.14$ или $0.5$? Существует два подхода: плавающая точка (Floating Point, стандарт IEEE 754) и фиксированная точка.

Фиксированная точка — это способ представления дробных чисел, при котором позиция разделителя целой и дробной части жестко зафиксирована.

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

Формат Q (Q-notation)

Часто используется запись вида Qn.m, где:

• $n$ — количество бит для целой части (иногда включая знак).
• $m$ — количество бит для дробной части.

Рассмотрим 8-битное число в формате Q4.4 (4 бита целых, 4 бита дробных).

Пусть в памяти записано число: 00101100.

Мы мысленно ставим точку посередине: 0010.1100.

Расчет значения

Значение числа рассчитывается как сумма степеней двойки, где дробные разряды имеют отрицательные степени:

$$V = \sum_{i=-m}^{n-1} b_i \cdot 2^i$$

Где $V$ — итоговое значение, $m$ — количество дробных бит, $n$ — количество целых бит, $b_i$ — значение бита (0 или 1) в позиции $i$, $2^i$ — вес разряда.

Разберем пример 0010.1100:

• Целая часть 0010: $0\cdot2^3 + 0\cdot2^2 + 1\cdot2^1 + 0\cdot2^0 = 2$
• Дробная часть 1100: $1\cdot2^{-1} + 1\cdot2^{-2} + 0\cdot2^{-3} + 0\cdot2^{-4}$

Посчитаем дробную часть:

$$1 \cdot 0.5 + 1 \cdot 0.25 = 0.75$$

Итоговое число: $2 + 0.75 = 2.75$.

Альтернативный взгляд: Масштабирование

Можно смотреть на это проще: мы храним целое число $I$, а реальное значение $R$ получаем делением на $2^m$ (где $m$ — количество дробных бит).

В нашем примере 00101100 как простое целое равно $44$. Поскольку у нас 4 дробных бита, делим на $2^4 = 16$:

$$R = \frac{44}{16} = 2.75$$

Где $R$ — реальное число, $44$ — целочисленное представление в памяти, $16$ — масштабный коэффициент.

Плюсы и минусы фиксированной точки

Преимущества:

• Скорость: Операции сложения и вычитания выполняются так же быстро, как с обычными целыми числами. Не нужен сопроцессор плавающей точки (FPU).
• Точность: Абсолютная погрешность постоянна по всему диапазону чисел.

Недостатки:

• Ограниченный диапазон: Мы не можем записывать очень большие и очень маленькие числа одновременно (в отличие от плавающей точки).
• Сложность умножения: При перемножении двух чисел формата Q4.4 результат будет иметь формат Q8.8, и его нужно приводить обратно к Q4.4, теряя точность.

Фиксированная точка — основной инструмент в микроконтроллерах, финансовом ПО (где важна точность до копейки и недопустимы ошибки округления плавающей точки) и графике реального времени.

Алгоритмы арифметических операций над числами с фиксированной точкой и обработка переполнения

В предыдущей статье мы разобрали, как числа хранятся в памяти компьютера, и выяснили, что дополнительный код (Two's Complement) является стандартом для представления знаковых целых чисел. Теперь пришло время заставить эти числа работать.

Как процессор складывает числа? Почему вычитание — это на самом деле сложение? И что происходит, когда результат вычисления становится слишком большим, чтобы поместиться в отведенную память? В этой статье мы разберем алгоритмы арифметики с фиксированной точкой и научимся предсказывать и обрабатывать переполнения.

Сложение и вычитание в дополнительном коде

Главное преимущество дополнительного кода заключается в том, что он унифицирует операции сложения и вычитания. Для процессора не существует операции «вычесть $B$ из $A$». Вместо этого он выполняет операцию «прибавить к $A$ отрицательное $B$».

$$A - B = A + (-B)$$

Где $A$ — уменьшаемое, $B$ — вычитаемое, а $-B$ — представление числа $B$ в дополнительном коде.

Это означает, что аппаратному сумматору (части процессора, отвечающей за сложение) не нужно знать, являются ли числа положительными или отрицательными. Он просто складывает биты, включая знаковый бит, и отбрасывает любой перенос, который выходит за пределы разрядной сетки.

Пример сложения чисел с разными знаками

Рассмотрим сложение чисел $5$ и $-3$ в 8-битной системе.

1. Число $5$ в двоичном виде: $00000101$.
2. Число $3$ в двоичном виде: $00000011$.
3. Число $-3$ в дополнительном коде: инвертируем биты ($11111100$) и прибавляем 1 $\rightarrow 11111101$.

Теперь выполним сложение столбиком:

$$\begin{array}{r} \phantom{+}00000101 \\ +\;11111101 \\ \hline 100000010 \end{array}$$

Здесь мы видим результат $100000010$. Обратите внимание, что результат получился 9-битным. Так как мы работаем в 8-битной арифметике, старший девятый бит (единица слева) просто отбрасывается (теряется).

Оставшиеся 8 бит: $00000010$. В десятичной системе это число $2$. Проверка: $5 + (-3) = 2$. Всё верно.

Этот механизм работает безупречно, пока результат помещается в доступное количество бит. Но что, если нет?

Проблема переполнения (Overflow)

Переполнение возникает, когда результат арифметической операции превышает диапазон значений, который может быть представлен в выбранном формате числа.

Для $N$-битного знакового числа диапазон значений составляет:

$$[-2^{N-1}, 2^{N-1} - 1]$$

Где $N$ — количество бит, $2^{N-1}$ — модуль минимального числа, а $2^{N-1} - 1$ — максимальное положительное число.

Для 8 бит этот диапазон: от $-128$ до $+127$.

Как обнаружить переполнение?

В знаковый арифметике переполнение может возникнуть только при сложении чисел с одинаковыми знаками.

• Если мы складываем два положительных числа и получаем отрицательное — произошло переполнение.
• Если мы складываем два отрицательных числа и получаем положительное — произошло переполнение.
• При сложении чисел с разными знаками переполнение невозможно (результат всегда будет ближе к нулю, чем слагаемые по модулю).

Пример переполнения

Попробуем сложить $127$ и $1$ в 8-битной системе.

• $127_{10} = 01111111_2$
• $1_{10} = 00000001_2$

$$\begin{array}{r} \phantom{+}01111111 \\ +\;00000001 \\ \hline 10000000 \end{array}$$

Результат: $10000000_2$. В знаковом представлении старший бит $1$ означает отрицательное число. Это код числа $-128$.

Мы получили: $127 + 1 = -128$. Это классический пример знакового переполнения.

В процессорах для фиксации этого события существует специальный флаг OF (Overflow Flag). Если после операции знак результата не совпадает со знаком слагаемых (при условии, что слагаемые имели одинаковый знак), флаг OF устанавливается в 1.

Умножение чисел с фиксированной точкой

Умножение сложнее сложения. Если при сложении двух $N$-битных чисел результат (обычно) помещается в $N$ бит (исключая переполнение), то при умножении двух $N$-битных чисел результат может занимать до $2N$ бит.

Например, умножая два 8-битных числа, мы должны быть готовы сохранить 16-битный результат.

Алгоритм умножения

Для компьютеров умножение — это серия сдвигов и сложений. Это похоже на умножение столбиком в десятичной системе, только проще, так как цифры могут быть только 0 или 1.

Если мы умножаем числа с фиксированной точкой, мы фактически умножаем их как целые числа, а затем должны правильно интерпретировать положение точки.

Пусть у нас есть два числа в формате с фиксированной точкой. Обозначим их как $A$ и $B$. Пусть формат представления имеет $F$ дробных бит (например, Q16.16, где $F=16$).

Математически значение числа $A$ равно:

$$Val(A) = I_A / 2^F$$

Где $Val(A)$ — реальное значение числа, $I_A$ — целое число, хранящееся в битах, а $2^F$ — масштабный коэффициент.

При умножении:

$$Val(A) \cdot Val(B) = \frac{I_A}{2^F} \cdot \frac{I_B}{2^F} = \frac{I_A \cdot I_B}{2^{2F}}$$

Где $Val(A) \cdot Val(B)$ — искомое произведение, $I_A \cdot I_B$ — результат целочисленного умножения, а $2^{2F}$ — новый масштабный коэффициент.

Это означает, что после перемножения «сырых» битовых значений, результат будет иметь в два раза больше дробных бит ($2F$). Чтобы вернуть его к исходному формату (с $F$ дробными битами), результат нужно разделить на $2^F$, то есть сдвинуть вправо на $F$ позиций.

Пример умножения с фиксированной точкой

Представим, что у нас 4-битная система, где 2 бита отведены под дробную часть (формат Q2.2). Масштабный коэффициент $2^2 = 4$.

Число $1.5$ в десятичной системе $\rightarrow 1.5 \times 4 = 6$ в «сыром» виде ($0110_2$). Число $0.5$ в десятичной системе $\rightarrow 0.5 \times 4 = 2$ в «сыром» виде ($0010_2$).

Умножаем «сырые» значения:

$$6 \times 2 = 12$$

В двоичном виде $12$ это $1100_2$.

Теперь вспоминаем про точку. У нас было 2 дробных бита у первого числа и 2 у второго. В результате у нас теперь 4 дробных бита. Число $1100_2$ интерпретируется как $0.1100_2$ (если считать все 4 бита дробными).

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

$12$ ($1100_2$) сдвигаем вправо на 2 $\rightarrow 3$ ($0011_2$).

Проверяем: «сырое» $3$ в формате Q2.2 означает $3 / 4 = 0.75$. Математически: $1.5 \times 0.5 = 0.75$. Всё верно.

Деление чисел с фиксированной точкой

Деление обратно умножению. Если при умножении количество дробных бит удваивается, то при делении оно может исчезнуть.

$$\frac{Val(A)}{Val(B)} = \frac{I_A / 2^F}{I_B / 2^F} = \frac{I_A}{I_B}$$

Где $I_A$ и $I_B$ — целочисленные представления. Заметьте, что множители $2^F$ сокращаются.

Если мы просто разделим целые части, мы получим целое число без дробной части. Например, $3 / 4$ в целочисленной арифметике даст $0$. Нам это не подходит.

Чтобы сохранить точность, перед делением делимое ($I_A$) нужно сдвинуть влево на $F$ бит (умножить на $2^F$).

$$Result = \frac{I_A \cdot 2^F}{I_B}$$

Где $Result$ — результат в формате с фиксированной точкой.

Особенности реализации

1. Потеря точности: При сдвигах вправо (после умножения) мы теряем младшие биты. Это вносит ошибку округления.
2. Переполнение при делении: Сдвиг делимого влево может вызвать переполнение еще до начала операции деления. Для этого часто используют расширенные регистры (например, 64-битный регистр для деления 32-битных чисел).

Арифметика с насыщением (Saturation Arithmetic)

В стандартной арифметике переполнение приводит к «оборачиванию» числа (wrap-around): $127 + 1 = -128$. Это математически корректно по модулю $2^N$, но катастрофично для обработки сигналов (звука, графики).

Представьте, что вы увеличиваете громкость звука. Если значение амплитуды превысит максимум и станет отрицательным, вместо громкого звука вы услышите резкий треск (инверсию волны).

Для решения этой проблемы используется арифметика с насыщением.

Правило простое: если результат операции превышает максимум, он остается равным максимуму. Если меньше минимума — остается равным минимуму.

• Обычная арифметика: $127 + 5 = -124$
• Арифметика с насыщением: $127 + 5 = 127$

Этот подход требует дополнительных проверок флага переполнения после каждой операции, но он критически важен в мультимедийных приложениях и DSP (цифровой обработке сигналов).

Заключение

Арифметика с фиксированной точкой — это мощный инструмент, который позволяет выполнять дробные вычисления, используя быстрые целочисленные блоки процессора. Главное — помнить о положении воображаемой запятой и внимательно следить за переполнениями.

Однако фиксированная точка имеет серьезное ограничение: узкий динамический диапазон. Мы не можем одновременно работать с очень большими и очень маленькими числами. Для решения этой задачи был придуман формат с плавающей точкой, о котором мы поговорим в следующих статьях курса.

Стандарт IEEE 754: структура, нормализация и диапазоны чисел с плавающей точкой

В предыдущей лекции мы подробно разобрали арифметику с фиксированной точкой. Мы выяснили, что это быстрый и эффективный способ вычислений, но он обладает критическим недостатком: узким динамическим диапазоном. Мы не можем одной и той же «линейкой» измерять и диаметр атома, и расстояние до соседней галактики.

Чтобы решить эту проблему, инженеры обратились к научной нотации записи чисел. Так появился формат с плавающей точкой (floating point), который сегодня является стандартом де-факто во всех современных вычислительных системах. Этот стандарт известен как IEEE 754.

От научной нотации к машинному слову

Вспомним, как ученые записывают очень большие или очень маленькие числа. Вместо того чтобы писать $300000000$, физик напишет $3.0 \times 10^8$.

В общем виде это выглядит так:

$$N = M \times B^E$$

Где $N$ — записываемое число, $M$ — мантисса (значащая часть), $B$ — основание системы счисления (в науке обычно 10), а $E$ — экспонента (порядок).

Компьютеры используют двоичную систему, поэтому для них основание $B = 2$. Стандарт IEEE 754 описывает, как именно упаковать знак, мантиссу и экспоненту в ограниченное количество бит (32 или 64), чтобы обеспечить максимальную точность и диапазон.

Структура числа IEEE 754

Рассмотрим самый популярный формат: одинарная точность (Single Precision, 32 бита), который в языках программирования часто называется float.

32 бита распределяются следующим образом:

1. Знак (Sign, S): 1 бит. Определяет, положительное число или отрицательное.
2. Экспонента (Exponent, E): 8 бит. Определяет порядок числа (масштаб).
3. Мантисса (Mantissa, M): 23 бита. Содержит значащие цифры числа.

Формула для вычисления значения числа выглядит так:

$$V = (-1)^S \times (1 + M) \times 2^{E - Bias}$$

Где $V$ — итоговое значение числа, $S$ — значение бита знака (0 или 1), $M$ — нормализованная мантисса (дробная часть), $E$ — значение экспоненты как целого беззнакового числа, а $Bias$ — смещение экспоненты (константа).

Давайте разберем каждый элемент этой формулы подробнее.

1. Знак (Sign)

Здесь всё просто, как и в числах с фиксированной точкой:

• 0 — число положительное.
• 1 — число отрицательное.

2. Нормализация и скрытая единица

В научной нотации принято записывать число так, чтобы перед запятой стояла ровно одна значащая цифра (не ноль). Например, мы пишем $1.23 \times 10^5$, а не $12.3 \times 10^4$ или $0.123 \times 10^6$.

В двоичной системе единственная возможная ненулевая цифра — это 1. Следовательно, любое нормализованное двоичное число выглядит как:

$$1.xxxxx... \times 2^E$$

Где $1$ — целая часть, $xxxxx...$ — дробная часть, а $2^E$ — множитель масштаба.

Создатели стандарта IEEE 754 пошли на хитрость. Раз целая часть нормализованного числа всегда равна 1, зачем тратить драгоценный бит памяти на её хранение? Мы можем просто подразумевать, что она там есть.

Поэтому в 23 битах мантиссы хранится только дробная часть (то, что стоит после запятой). При восстановлении числа процессор автоматически добавляет к мантиссе единицу. Это называется скрытая единица (implicit leading bit). Фактически, имея 23 бита памяти, мы получаем точность в 24 бита.

3. Смещенная экспонента (Biased Exponent)

Экспонента может быть как положительной (для больших чисел, например $2^{50}$), так и отрицательной (для маленьких чисел, например $2^{-50}$).

Чтобы не возиться с дополнительным кодом для экспоненты и упростить операции сравнения чисел, стандарт использует смещение (Bias). Экспонента хранится как беззнаковое целое число, но при вычислении реального значения из него вычитается константа.

Для типа float (8 бит экспоненты) смещение $Bias = 127$.

• Если в битах экспоненты записано $127$ ($01111111_2$), реальная степень равна $127 - 127 = 0$.
• Если записано $128$ ($10000000_2$), реальная степень равна $128 - 127 = 1$.
• Если записано $100$ ($01100100_2$), реальная степень равна $100 - 127 = -27$.

Диапазон хранимых значений экспоненты: от 0 до 255. Однако значения 0 и 255 зарезервированы для специальных случаев (о них ниже), поэтому реальный диапазон степеней двойки: от $-126$ до $+127$.

Пример: Перевод числа в формат IEEE 754

Попробуем вручную перевести число -13.625 в формат float.

Шаг 1. Определяем знак. Число отрицательное, значит бит знака $S = 1$.

Шаг 2. Переводим модуль числа в двоичный вид. Целая часть: $13_{10} = 1101_2$. Дробная часть: $0.625_{10} = 0.101_2$ (так как $0.5 + 0.125 = 0.625$). Итого: $1101.101_2$.

Шаг 3. Нормализуем число. Сдвигаем запятую влево так, чтобы перед ней осталась одна единица:

$$1101.101_2 = 1.101101_2 \times 2^3$$

Где $1.101101_2$ — мантисса с целой частью, а $3$ — реальная степень.

Шаг 4. Вычисляем смещенную экспоненту. Реальная степень $E_{real} = 3$. Хранимая экспонента $E_{stored} = E_{real} + Bias = 3 + 127 = 130$. Переводим 130 в двоичный вид: $130_{10} = 10000010_2$.

Шаг 5. Формируем мантиссу. Берем дробную часть от нормализованного числа ($101101$). Отбрасываем ведущую единицу (она скрытая). Дополняем нулями справа до 23 бит. Мантисса: $10110100000000000000000$.

Результат:

$$\underbrace{1}_{S} \; \underbrace{10000010}_{E} \; \underbrace{10110100000000000000000}_{M}$$

В шестнадцатеричном виде: 0xC15A0000.

Специальные значения

В стандарте IEEE 754 есть комбинации битов, которые интерпретируются особым образом. Они кодируются с помощью зарезервированных значений экспоненты (все нули или все единицы).

Экспонента	Мантисса	Значение
0 (00...0)	0 (00...0)	Нуль (Zero). Причем существует $+0$ и $-0$.
0 (00...0)	Не 0	Денормализованные числа. Очень маленькие числа, близкие к нулю, у которых нет скрытой единицы.
255 (11...1)	0 (00...0)	Бесконечность ($\,\infty$). Возникает при переполнении или делении на ноль. Бывает $+\infty$ и $-\infty$.
255 (11...1)	Не 0	NaN (Not a Number). Результат некорректных операций, например $\sqrt{-1}$ или $0/0$.

Диапазоны и точность

Важно понимать ограничения форматов. Числа с плавающей точкой распределены на числовой оси неравномерно: они очень густо расположены возле нуля и становятся всё более редкими по мере удаления от него.

Одинарная точность (float, 32 бита)

• Диапазон: примерно от $\pm 1.18 \times 10^{-38}$ до $\pm 3.4 \times 10^{38}$.
• Точность: около 7 десятичных знаков. Это значит, что число $123456789$ может быть сохранено только приблизительно (например, как $123456792$).

Двойная точность (double, 64 бита)

Использует 11 бит под экспоненту и 52 бита под мантиссу. Смещение экспоненты $1023$.

• Диапазон: примерно от $\pm 2.23 \times 10^{-308}$ до $\pm 1.80 \times 10^{308}$.
• Точность: около 15-16 десятичных знаков.

Заключение

Стандарт IEEE 754 — это компромисс между точностью и диапазоном. Благодаря скрытой единице и смещенной экспоненте, мы можем эффективно хранить и обрабатывать числа колоссальных величин.

Однако за эту гибкость приходится платить сложностью арифметических операций и ошибками округления, которые неизбежны при работе с плавающей точкой. О том, как именно процессор складывает и умножает такие числа, и почему $0.1 + 0.2 \neq 0.3$, мы поговорим в следующей статье.

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

В предыдущей статье мы познакомились со стандартом IEEE 754 и узнали, как компьютеры упаковывают огромный диапазон значений в 32 или 64 бита. Мы выяснили, что число с плавающей точкой состоит из трех компонентов: знака, экспоненты (порядка) и мантиссы.

Однако хранение данных — это лишь полдела. Главная задача процессора — вычислять. И если умножение чисел с плавающей точкой выполняется относительно просто (нужно перемножить мантиссы и сложить экспоненты), то сложение и вычитание — это настоящая алгоритмическая полоса препятствий.

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

Проблема разных масштабов

Представьте, что вам нужно сложить 1 километр и 500 метров. Вы не можете просто сложить $1 + 500$ и получить $501$. Сначала вам нужно привести величины к одной единице измерения: либо $1000\text{ м} + 500\text{ м} = 1500\text{ м}$, либо $1\text{ км} + 0.5\text{ км} = 1.5\text{ км}$.

То же самое происходит с числами в научной нотации. Попробуем сложить два числа:

$$A = 1.23 \cdot 10^5$$

Где $A$ — первое слагаемое, представленное как $1.23$ умноженное на $10$ в степени $5$.

$$B = 4.56 \cdot 10^3$$

Где $B$ — второе слагаемое, представленное как $4.56$ умноженное на $10$ в степени $3$.

Мы не можем сложить мантиссы $1.23$ и $4.56$ напрямую, так как они имеют разный «вес». Число $A$ в 100 раз «тяжелее» числа $B$. Чтобы выполнить сложение, мы должны привести число с меньшим порядком к порядку большего числа.

$$B = 4.56 \cdot 10^3 = 0.0456 \cdot 10^5$$

Теперь порядки равны ($10^5$), и мы можем сложить мантиссы:

$$A + B = (1.23 + 0.0456) \cdot 10^5 = 1.2756 \cdot 10^5$$

Этот процесс называется выравниванием порядков. В компьютере он происходит в двоичной системе, но принцип остается тем же.

Алгоритм сложения/вычитания IEEE 754

Процесс выполнения арифметической операции в арифметико-логическом устройстве (АЛУ) процессора можно разделить на несколько ключевых этапов.

Этап 1: Распаковка и восстановление скрытой единицы

Числа хранятся в памяти в упакованном виде. Первым делом процессор разделяет их на части:

• Знак ($S$)
• Экспонента ($E$)
• Мантисса ($M$)

Важный момент: в формате IEEE 754 целая часть нормализованного числа (единица) не хранится явно. На этом этапе процессор «вспоминает» о ней и добавляет к мантиссе слева. Теперь мантисса имеет вид $1.xxxxx...$

Этап 2: Выравнивание порядков (Alignment)

Пусть у нас есть два числа с экспонентами $E_1$ и $E_2$. Процессор сравнивает их и находит разность:

$$\Delta E = |E_1 - E_2|$$

Где $\Delta E$ — разница между экспонентами.

Если $E_1 = E_2$, выравнивание не требуется. Если же экспоненты отличаются, мантиссу числа с меньшей экспонентой нужно сдвинуть вправо на $\Delta E$ позиций. При каждом сдвиге вправо значение экспоненты этого числа виртуально увеличивается на 1, пока не сравняется с большей экспонентой.

Почему сдвигаем именно меньшее число? Если мы будем сдвигать большее число влево (уменьшая его экспоненту), мы можем получить очень большое целое число, которое переполнит регистр. Сдвиг меньшего числа вправо безопаснее: мы просто теряем младшие биты (точность), но сохраняем порядок величины.

Этап 3: Сложение или вычитание мантисс

Теперь, когда экспоненты равны, мы работаем только с мантиссами. Операция зависит от знаков чисел:

• Если знаки одинаковы ($5 + 2$ или $-5 + (-2)$), мантиссы складываются.
• Если знаки разные ($5 + (-2)$), из большей мантиссы вычитается меньшая, а результат получает знак большего числа.

На этом этапе мы получаем промежуточный результат мантиссы ($M_{res}$).

Этап 4: Нормализация результата

После сложения мантисс результат может перестать быть нормализованным. Возможны два случая нарушения стандарта:

Случай А: Переполнение мантиссы (Overflow) При сложении двух чисел вида $1.xxx$ результат может стать больше или равен 2 (например, $1.5 + 1.5 = 3.0$, что в двоичном виде $11.0$). Стандарт требует, чтобы перед запятой стояла только одна единица.

• Действие: Сдвигаем мантиссу результата вправо на 1 бит.
• Коррекция экспоненты: Увеличиваем экспоненту результата на 1.

Случай Б: Потеря значимости (Underflow) При вычитании близких чисел результат может стать меньше 1 (например, $1.5 - 1.25 = 0.25$, что в двоичном виде $0.01$). Ведущая единица исчезла, появились ведущие нули.

• Действие: Сдвигаем мантиссу результата влево, пока первая единица не окажется перед запятой.
• Коррекция экспоненты: Уменьшаем экспоненту на количество сделанных сдвигов.

Этап 5: Округление и упаковка

Мантисса результата может не поместиться в отведенные 23 бита (для float). Лишние биты необходимо отбросить, используя один из режимов округления (обычно — к ближайшему четному). После этого отбрасывается ведущая единица (она снова становится скрытой), и число упаковывается обратно в формат IEEE 754.

Практический пример

Попробуем сложить два числа в 4-битной упрощенной модели (для наглядности), где мантисса имеет 3 бита после запятой.

Сложим $2.5$ и $0.25$.

1. Представление чисел: $2.5_{10} = 10.1_2 = 1.010_2 \cdot 2^1$ $0.25_{10} = 0.01_2 = 1.000_2 \cdot 2^{-2}$

• Число А: Мантисса $1.010$, Экспонента $1$
• Число Б: Мантисса $1.000$, Экспонента $-2$

2. Выравнивание: Разница экспонент: $1 - (-2) = 3$. Число Б имеет меньшую экспоненту. Сдвигаем его мантиссу вправо на 3 позиции. Было: $1.000$ Сдвиг 1: $0.100$ (эксп $-1$) Сдвиг 2: $0.010$ (эксп $0$) Сдвиг 3: $0.001$ (эксп $1$)

Теперь оба числа имеют экспоненту $1$. Мантисса Б стала $0.001$.

3. Сложение:

$$\begin{array}{r} 1.010 \\ +\;0.001 \\ \hline 1.011 \end{array}$$

Результат: $1.011$ при экспоненте $1$.

4. Нормализация: Число $1.011$ уже нормализовано (одна единица перед запятой). Действий не требуется.

5. Результат: $1.011_2 \cdot 2^1 = 10.11_2 = 2 + 0.5 + 0.25 = 2.75_{10}$. Ответ верный.

Потеря точности и «съедание» малых чисел

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

Представьте, что вы складываете $10^{20}$ и $1$. В формате float (одинарная точность) мантисса вмещает около 7 десятичных цифр. Чтобы выровнять порядки, число $1$ нужно сдвинуть вправо на 20 позиций. Но мантисса имеет всего 23 бита! Единица просто «выпадет» за пределы разрядной сетки и превратится в ноль.

$$10^{20} + 1 = 10^{20}$$

Для компьютера это равенство истинно. Маленькое число было полностью поглощено большим. Это явление называется поглощением (absorption).

Катастрофическая отмена (Catastrophic Cancellation)

Еще более опасная ситуация возникает при вычитании двух очень близких чисел.

Допустим, мы вычитаем $1.234567$ и $1.234566$. Оба числа имеют 7 значащих цифр. Результат: $0.000001$.

В нормализованном виде это $1.000000 \cdot 10^{-6}$. Но обратите внимание: у нас осталась всего одна значащая цифра точности! Остальные цифры мантиссы будут заполнены нулями, которые не несут полезной информации. Мы потеряли 6 порядков точности за одну операцию. Если этот результат будет использоваться в дальнейших вычислениях (например, делении), ошибка будет нарастать лавинообразно.

Заключение

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

Понимание механизма выравнивания и нормализации позволяет программисту предвидеть, где могут возникнуть потери точности, и избегать таких операций, как сложение чисел несопоставимых величин или вычитание слишком близких значений.

В следующей статье мы рассмотрим операции умножения и деления, которые, как ни странно, структурно проще сложения, но имеют свои подводные камни.

Умножение и деление вещественных чисел, анализ погрешностей и особые ситуации

Мы продолжаем наш курс «Арифметика в ЭВМ». В прошлой лекции мы убедились, что сложение чисел с плавающей точкой — это нетривиальная задача, требующая выравнивания порядков (экспонент). Это похоже на попытку сложить метры с километрами: сначала нужно привести всё к одной единице измерения.

Сегодня мы переходим к умножению и делению. Парадоксально, но алгоритмически эти операции проще сложения, так как не требуют выравнивания порядков. Однако они таят в себе другие опасности: переполнение экспоненты, потерю значимости и накопление погрешностей, из-за которых математика в компьютере перестает работать так, как мы привыкли в школе.

Почему $0.1 + 0.2$ в Python или Java не равно $0.3$? Что такое «машинный ноль»? И что произойдет, если разделить бесконечность на бесконечность? Давайте разбираться.

Алгоритм умножения чисел с плавающей точкой

Вспомним формулу представления числа в стандарте IEEE 754:

$$V = (-1)^S \cdot (1 + M) \cdot 2^{E - Bias}$$

Где $V$ — значение числа, $S$ — знак, $M$ — дробная часть мантиссы, $E$ — хранимая экспонента, $Bias$ — смещение (127 для float).

При умножении двух чисел $A$ и $B$ мы фактически выполняем действия над степенями:

$$(M_A \cdot 2^{E_A}) \cdot (M_B \cdot 2^{E_B}) = (M_A \cdot M_B) \cdot 2^{E_A + E_B}$$

Где $M_A, M_B$ — полные мантиссы (со скрытой единицей), а $E_A, E_B$ — реальные порядки чисел.

Процесс умножения в процессоре разбивается на четыре независимых этапа.

1. Вычисление знака

Это самая простая часть. При умножении (и делении) знак результата отрицателен, если знаки операндов различаются. В двоичной логике это операция XOR (исключающее ИЛИ) над знаковыми битами.

• $0 (plus) \oplus 0 (plus) = 0 (plus)$
• $1 (minus) \oplus 1 (minus) = 0 (plus)$
• $1 (minus) \oplus 0 (plus) = 1 (minus)$

2. Сложение экспонент

Здесь кроется нюанс. В памяти мы храним не реальные экспоненты, а смещенные ($E_{stored} = E_{real} + Bias$). Если мы просто сложим два хранимых значения, то смещение удвоится:

$$(E_{realA} + Bias) + (E_{realB} + Bias) = E_{realA} + E_{realB} + 2 \cdot Bias$$

Где $E_{realA}, E_{realB}$ — реальные порядки, а $Bias$ — константа смещения.

Нам же нужно, чтобы в результате получилось число с одним смещением ($E_{result} + Bias$). Поэтому из суммы хранимых экспонент необходимо вычесть одно значение $Bias$:

$$E_{new} = E_{storedA} + E_{storedB} - Bias$$

Где $E_{new}$ — новая хранимая экспонента результата, $E_{storedA}$ и $E_{storedB}$ — экспоненты исходных чисел.

Для формата float (где $Bias = 127$) это означает, что процессор складывает два 8-битных числа и вычитает 127.

3. Умножение мантисс

Мантиссы перемножаются как обычные целые числа с фиксированной точкой. Поскольку каждая мантисса нормализована (находится в диапазоне $[1, 2)$), их произведение будет находиться в диапазоне:

$$1 \le (M_A \cdot M_B) < 4$$

Где $M_A \cdot M_B$ — результат перемножения мантисс.

Это означает, что результат может быть либо вида $1.xxxx...$, либо $1x.xxxx...$ (то есть больше или равен 2).

4. Нормализация и округление

Если произведение мантисс получилось больше или равно 2 (например, $1.5 \cdot 1.5 = 2.25$, что в двоичном виде $10.01_2$), результат нужно нормализовать:

1. Сдвигаем запятую на одну позицию влево ($10.01 \to 1.001$).
2. Увеличиваем вычисленную экспоненту на 1.

После этого результат округляется до 23 бит (для float), и ведущая единица снова становится скрытой.

Алгоритм деления

Деление симметрично умножению, но операции инвертируются.

$$\frac{M_A \cdot 2^{E_A}}{M_B \cdot 2^{E_B}} = \frac{M_A}{M_B} \cdot 2^{E_A - E_B}$$

Где $M_A / M_B$ — частное мантисс, а $E_A - E_B$ — разность порядков.

1. Знак: Также вычисляется через XOR.
2. Экспонента: Мы вычитаем экспоненты. При этом смещения уничтожаются ($Bias - Bias = 0$). Чтобы вернуть формат к стандарту, нужно прибавить $Bias$ обратно:

   $$E_{new} = E_{storedA} - E_{storedB} + Bias$$

   Где $E_{new}$ — экспонента результата.
3. Мантисса: Делим мантиссу делимого на мантиссу делителя. Результат деления двух чисел из диапазона $[1, 2)$ будет лежать в диапазоне $(0.5, 2)$.
4. Нормализация: Если результат меньше 1 (например, $0.xxx...$), сдвигаем мантиссу влево и уменьшаем экспоненту.

Анализ погрешностей: почему 0.1 + 0.2 != 0.3

Самая большая проблема вещественных чисел в компьютере — это не сложность алгоритмов, а невозможность точно представить многие числа.

В десятичной системе мы привыкли, что $1/3 = 0.3333...$ — это бесконечная дробь. Мы не можем записать её точно на листе бумаги. В двоичной системе происходит то же самое, но с другими числами.

Любая дробь, знаменатель которой не является степенью двойки, в двоичной системе будет бесконечной периодической дробью. Число $0.1$ (одна десятая) — это $1/10$. Знаменатель $10 = 2 \cdot 5$. Наличие множителя 5 гарантирует, что в двоичном виде это будет бесконечная дробь:

$$0.1_{10} = 0.00011001100110011..._2$$

Где последовательность $0011$ повторяется бесконечно.

Компьютер имеет всего 23 бита для хранения мантиссы. Он вынужден обрезать эту последовательность и округлить её. В итоге в памяти хранится не ровно $0.1$, а число, очень близкое к нему: примерно $0.10000000149011611938...$

Когда мы складываем «почти 0.1» и «почти 0.2», ошибки суммируются, и результат оказывается чуть больше, чем «почти 0.3». Проверка на равенство if (a + b == 0.3) выдаст False.

Машинный эпсилон

Как же тогда сравнивать числа? Для этого вводится понятие машинного эпсилона ($\epsilon$). Это минимальное число, которое при прибавлении к 1.0 дает результат, отличный от 1.0.

Для одинарной точности (float) $\epsilon \approx 1.19 \cdot 10^{-7}$. Для двойной точности (double) $\epsilon \approx 2.22 \cdot 10^{-16}$.

Сравнение чисел должно происходить так: «равны ли числа с точностью до эпсилон?»

$$|A - B| < \epsilon$$

Где $|A - B|$ — модуль разности чисел, а $\epsilon$ — допустимая погрешность.

Особые ситуации и исключения

Стандарт IEEE 754 определяет четкие правила для ситуаций, когда результат не может быть представлен обычным числом.

1. Деление на ноль

В школьной математике делить на ноль нельзя. В арифметике с плавающей точкой — можно. Результат зависит от знака:

• $+5.0 / +0.0 = +\infty$ (Плюс бесконечность)
• $-5.0 / +0.0 = -\infty$ (Минус бесконечность)

Бесконечности ведут себя логично: $\infty + 5 = \infty$, $\infty \cdot 2 = \infty$. Но $\infty - \infty$ — это неопределенность.

2. NaN (Not a Number)

Если операция не имеет математического смысла, процессор возвращает специальное значение NaN (не число). Примеры:

• $0.0 / 0.0$
• $\infty - \infty$
• $\infty / \infty$
• $\sqrt{-1}$ (для вещественных чисел)

Главное свойство NaN — он «токсичен». Любая операция с NaN дает в результате NaN ($5 + \text{NaN} = \text{NaN}$).

Важно: NaN не равен ничему, даже самому себе. Выражение NaN == NaN вернет False. Это единственный случай в программировании, когда переменная не равна сама себе. Для проверки используется функция isNaN().

3. Переполнение (Overflow) и исчезновение (Underflow)

• Overflow: Если число по модулю становится больше максимального ($\approx 3.4 \cdot 10^{38}$ для float), оно превращается в $\infty$.
• Underflow: Если число становится меньше минимального нормализованного ($\approx 1.18 \cdot 10^{-38}$), оно теряет точность и превращается в денормализованное число, а затем в ноль.

Заключение

Арифметика с плавающей точкой — это мощный инструмент, но он требует понимания внутренней кухни. Умножение и деление здесь выполняются через манипуляции с экспонентами, а точность всегда ограничена количеством бит мантиссы.

Главный урок, который нужно вынести: никогда не используйте числа с плавающей точкой для финансовых расчетов, где важна каждая копейка. Для денег существуют специальные типы данных (например, Decimal), работающие по принципам фиксированной точки или десятичной арифметики, о которых мы говорили в начале курса.

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