bulgakov

12. Почему дробные числа бывают неточными

Для деления 8.0 / 3 мы выбрали double, чтобы сохранить дробную часть. Но double не может хранить бесконечное количество цифр: под значение выделена конечная память. Это ограничение касается не только бесконечных десятичных дробей.

Дробные разряды в двоичной системе

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

Вес:       1/2   1/4   1/8
Цифры:  0 . 1     0     1

Поэтому:

0.1012=12+18=0.6250.101_2 = \frac12 + \frac18 = 0.625

Здесь число записалось точно: 0.625=580.625=\frac{5}{8}, а восьмые доступны в двоичной системе. С одной десятой так не выйдет. Если сложить конечное число половин, четвертей, восьмых и следующих двоичных долей, получится дробь вида m2k\frac{m}{2^k} — после сокращения в знаменателе останутся только двойки. В точной дроби 110\frac{1}{10} есть множитель 55. Поэтому двоичная запись 0.1 бесконечна, как десятичная запись 13=0,3333…\frac{1}{3}=0{,}3333\ldots.

В распространённом двоичном формате double число 0.1 приходится заменить близким представимым значением. Приближение возникает уже при сохранении: вместо точной одной десятой в памяти оказывается близкое двоичное число.

Одно значение — разное количество знаков на экране

Полная программа:

C
#include <stdio.h>

int main(void)
{
    double value = 0.1;

    printf("%.2f\n", value);
    printf("%.17f\n", value);
    return 0;
}

На обычной системе с форматом IEEE 754 binary64 для double:

0.10
0.10000000000000001

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

  • %.2f показывает две цифры после точки. Маленькое отличие от точной десятой при таком выводе незаметно.
  • %.17f показывает семнадцать цифр после точки. На этой длине становится видна разница.

printf округляет текстовый результат до указанного количества знаков. Она не меняет value и не увеличивает точность хранящегося числа. Такой длинный хвост сам по себе не означает ошибку программы.

Зачем существуют float и double

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

123.45=1.2345⋅102123.45 = 1.2345\cdot10^2

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

Ограничение действует и при вычислениях: складываются уже сохранённые приближения, а результат тоже должен поместиться в доступную запись. Например, этот самостоятельный фрагмент внутри main с <stdio.h>:

C
double sum = 0.1 + 0.2;
printf("%.17f\n", sum);

На обычной системе с double в формате IEEE 754 binary64 и округлением к ближайшему вывод будет 0.30000000000000004. Мы записали обычную сумму, но точные десятые не помещаются в её двоичную запись. Формат %.2f показал бы 0.30, скрыв малую разницу; само вычисление он не исправляет.

У распространённых форматов float получается около 6–7 значащих десятичных цифр, у double — 15–16. Это цифры всего числа, а не только дробной части: в 12345.6 шесть значащих цифр, и в 0.0000123456 тоже шесть. Нули перед первой значащей цифрой лишь задают масштаб.

Поэтому double обычно сохраняет больше подробностей результата вычисления. Однако ни float, ни double не обещают точного хранения любой десятичной дроби. Конкретные характеристики реализации можно получить из <float.h>; сами размеры и форматы зависят от платформы.

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

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

Полная программа:

C
#include <stdio.h>

int main(void)
{
    float start = 16777216.0f;
    float after_one = start + 1.0f;
    float after_two = start + 2.0f;

    printf("Start: %.0f\n", start);
    printf("Plus 1: %.0f\n", after_one);
    printf("Plus 2: %.0f\n", after_two);
    return 0;
}

Для распространённого float в формате IEEE 754 binary32 при обычном округлении к ближайшему, с выбором чётного при равенстве расстояний:

Start: 16777216
Plus 1: 16777216
Plus 2: 16777218

В этом формате доступны 24 значащих двоичных разряда. Сразу после 224=167772162^{24}=16777216 для единичного шага понадобился бы 25-й, поэтому здесь представимы числа 16777216, 16777218, 16777220 и так далее, с шагом два. Точная сумма 16777217 находится ровно посередине между первыми двумя. При таком равенстве расстояний правило округления выбирает число с последним двоичным разрядом значащей части 0 — здесь 16777216. Сумма с двойкой уже представима точно.

Большой диапазон не означает, что каждое число внутри него можно сохранить точно. Это объясняет, почему float может быть неудачным выбором для большого целого счётчика. double в распространённом формате binary64 имеет больше значащих разрядов и сохраняет показанные три целых значения точно; однако на достаточно больших числах похожая проблема возникнет и у него.

Если встречается long double

В C есть и long double. Для числа этого типа добавляют к записи суффикс L, а в printf используют формат %Lf. Полная программа:

C
#include <stdio.h>

int main(void)
{
    long double value = 0.1L;
    printf("Value: %.2Lf\n", value);
    return 0;
}

Вывод — Value: 0.10. Суффикс L относится к числу в исходнике, тип long double — к сохранённому значению, а .2 задаёт лишь два знака на экране. От этого вывода нельзя заключить, что 0.1 хранится точно. Реализация может дать long double больше точности, чем double, а может использовать для них одинаковую точность. Проверять характеристики на своей платформе можно через <float.h>, например LDBL_DIG показывает количество гарантированных значащих десятичных цифр для long double.

Почему иногда видно inf

На многих системах с арифметикой IEEE 754 деление ненулевого float на 0.0f даёт специальное значение бесконечности: для положительного числа можно увидеть inf, для отрицательного — -inf. Это не универсальный результат обычного C17: поддержка таких правил зависит от реализации. Если программе нужен обычный числовой результат, проверьте знаменатель до деления. Бесконечность здесь не означает, что в переменной поместилось очень большое конечное число.

Приведение типа и форматирование решают разные задачи. (int)3.9 получает новое целое значение 3. А printf("%.0f", 3.9) задаёт вывод без цифр после точки и показывает округлённый текст 4, не превращая исходное значение в целочисленное. При чтении результата сначала смотрите, что программа вычислила, а затем — как она попросила это показать.

ПрактикаЗагружаем тест…