Нюансы работы с вещественными числами

Открыта

Квест Java Syntax Pro еще в разработке

Сейчас мы вычитываем лекции и работаем над задачами. Если заметили ошибки — пишите в комментариях: всё учтем перед релизом. Спасибо!

1. Округление вещественных чисел

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

А ведь легко можно представить ситуацию, когда дробное число нужно округлить просто до ближайшего целого или вообще вверх. Что делать в этой ситуации?

Для этого и для многих похожих случаев в Java есть класс Math, у которого есть методы round(), ceil(), floor().


Метод Math.round()

Метод Math.round() округляет число до ближайшего целого:

long x = Math.round(вещественное_число)

Но, как говорится, есть нюанс: результат работы этого метода — целочисленный тип long (не int). Вещественные числа ведь могут быть очень большими, поэтому разработчики Java решили использовать самый большой целочисленный тип, который есть в Java — long.

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

int x = (int) Math.round(вещественное_число)

Примеры:

Команда Результат
int x = (int) Math.round(4.1);
4
int x = (int) Math.round(4.5);
5
int x = (int) Math.round(4.9);
5

Метод Math.ceil()

Метод Math.ceil() округляет число до целого вверх, примеры:

Команда Результат
int x = (int) Math.ceil(4.1);
5
int x = (int) Math.ceil(4.5);
5
int x = (int) Math.ceil(4.9);
5

Метод Math.floor()

Метод Math.floor() округляет число до целого вниз, примеры:

Команда Результат
int x = (int) Math.floor(4.1);
4
int x = (int) Math.floor(4.5);
4
int x = (int) Math.floor(4.9);
4

Хотя, для округления числа до целого вниз, будет проще использовать просто оператор приведения типа — (int):

Команда Результат
int x = (int) 4.9
4

Если вам сложно запомнить эти команды, вам поможет небольшой урок английского:

  • Math — математика
  • Round — круг/округлять
  • Ceiling — потолок
  • Floor — пол


2. Устройство чисел с плавающей точкой

Тип double может хранить значения в диапазоне -1.7*10308 до +1.7*10308. Такой гигантский диапазон значений (по сравнению с типом int) объясняется тем, что тип double (как и float) устроен совсем иначе по сравнению с целыми типами. Каждая переменная типа double содержит два числа: первое называется мантисса, а второе — степень.

Допустим, у нас есть число 123456789, и мы сохранили его в переменную типа double. Тогда число будет преобразовано к виду 1.23456789*108, и внутри типа double будут храниться два числа — 23456789 и 8. Красным выделена «значащая часть числа» (манти́сса), синим — степень.

Такой подход позволяет хранить как очень большие числа, так и очень маленькие. Но т.к. размер числа ограничен 8 байтами (64 бита) и часть бит используется под хранение степени (а также знака числа и знака степени), максимальная длина мантиссы ограничена 15 цифрами.

Это очень упрощенное описание устройства вещественных чисел, более полное можно найти по ссылке.


3. Потеря точности при работе с вещественными числами

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

Последнее — самая неожиданная ситуация для новичков в программировании.

Если из числа 109 вычесть 1/109, мы получим опять 109.

Вычитание чисел слишком разных размерностей Объяснение
1000000000.000000000;
-         0.000000001;
 1000000000.000000000;
Второе число слишком маленькое, и его значащая часть игнорируется (выделено серым). Оранжевым выделены 15 значащих цифр.

Что тут сказать, программирование — это не математика.


4. Опасность сравнения вещественных чисел

Еще одна опасность подстерегает программистов при сравнении вещественных чисел. Т.к. при работе с этими числами могут накапливаться ошибки округления, то возможны ситуации, когда вещественные числа должны быть равны, но они не равны. И наоборот: числа должны быть не равны, но они равны.

Пример:

Команда Пояснение
double a = 1000000000.0;
double b = 0.000000001;
double c = a - b;
В переменной a будет значение 1000000000.0
В переменной c будет значение 1000000000.0
(число в переменной b слишком маленькое)

В приведенном выше примере a и c не должны быть равны, но они равны.

Или возьмем другой пример:

Команда Пояснение
double a = 1.00000000000000001;
double b = 1.00000000000000002;
В переменной a будет значение 1.0
В переменной b будет значение 1.0

5. Интересный факт о strictfp

В Java есть специальное ключевое слово strictfp (strict floating point), которого нет в других языках программирования. И знаете, зачем оно нужно? Оно ухудшает точность работы с вещественными числами. История его появления примерно такова:

Создатели Java:
Мы очень хотим, чтобы Java была суперпопулярна, и программы на Java выполнялись на как можно большем количестве устройств. Поэтому мы прописали в спецификацию Java-машины, что на всех типах устройств все программы должны выполняться одинаково!
Создатели процессора Intel:
Ребята, мы улучшили наши процессоры, и теперь все вещественные числа внутри процессора будет представлены не 8-ю, а 10-ю байтами. Больше байт — больше знаковых цифр. А это значит что? Правильно: теперь ваши научные вычисления будут еще более точными!
Ученые и все, кто занимается сверхточными расчетами:
Круто! Молодцы. Отличная новость.
Создатели Java:
Не-не-не, ребята. Мы же сказали: все Java-программы должны выполняться одинаково на всех устройствах. Принудительно выключаем возможность использования 10 байтовых вещественных чисел внутри процессоров Intel.
Вот теперь все опять отлично! Не благодарите.
Ученые и все, кто занимается сверхточными расчетами:
Да вы там совсем охренели? Ану быстро вернули все как было!
Создатели Java:
Ребята, это для вашей же пользы! Только представьте: все Java-программы выполняются одинаково на всех устройствах. Ну круто же!
Ученые и все, кто занимается сверхточными расчетами:
Нет. Совсем не круто. Быстро вернули все обратно! Или мы вашу Java вам знаете куда засунем?
Создатели Java:
Гм. Что же вы сразу не сказали. Конечно, вернем.
Вернули возможность пользоваться всеми фичами крутых процессоров.
Кстати. Мы так же специально добавили в язык слово strictfp: если его написать перед именем функции, вся работа с вещественными числами внутри этой функции будет одинаково плохой на всех устройствах!
Комментарии (15)
  • популярные
  • новые
  • старые
Для того, чтобы оставить комментарий вы должны авторизоваться
MrLaykin
3 уровень
25 января, 16:05
Ученые и все, кто занимается сверхточными расчетами:
Да вы там совсем охренели? Ану быстро вернули все как было!
Ошибка в слове "Ану","Ану"должно писаться раздельно
Татьяна
6 уровень, Москва
5 декабря 2020, 20:27
"Да вы там совсем охренели? А ну быстро вернули все как было!" Ахахаха))) ой как круто))) прямо запомнилась вся статья)) только если для детей, то кажется это слишком грубо, а вот для взрослых отлично если иногда - мозг включает!
SEJAVASU
11 уровень, Москва
21 ноября 2020, 16:49
а гидэ пример с strictfp?
Andrei_Pivovar91
0 уровень, Санкт-Петербург
10 ноября 2020, 18:19
А описание п.8.5 будет дальше? Не понятно как пользоваться этим оператором.
Elena
16 уровень, Санкт-Петербург
18 августа 2020, 13:50
Ану А ну. Орфография
igohome11
12 уровень, Санкт-Петербург
2 июля 2020, 17:51
IJ уже по поводу long тоже ругается и просит по аналогии с int согласиться с конвертацией.
Ira Tsygarova
36 уровень, Санкт-Петербург
7 мая 2020, 19:11
8.2* Устройство чисел с плавающей точкой На сколько я помню, то мантисса представляет собой число, которое больше 0.1 и меньше 1 В вашем примере она больше 1 и написано, что в памяти хранится только число 23456789, которое при умножении на 10^8 будет давать 23456789, а не 123456789 как было изначально в примере. Это как раз из-за того, что неправильно обозначена мантисса должно быть 0.123456789 * 10^9 и число 123456789 хранится в одной части, а 9(степень 10) в другой
Сергей
14 уровень, Санкт-Петербург
30 апреля 2020, 16:14
п.8.3
Оранжевым выделены 15 значащих цифр.
Не увидел оранжевого выделения(мобильное приложение Android 9)
Алексей Иванов
23 уровень, Cheboksary
10 апреля 2020, 06:37
8.2 Разве в значащую часть числа (мантиссу) не входит цифра перед запятой? Ведь 1.23456789*10(8) не тоже самое, что 2.23456789*10(8)
елена
8 уровень, Москва
28 апреля 2020, 08:44
Почитываю параллельно с боевым курсом. Много нового и интересного. Но мне этот момент с мантиссой тоже здесь неясен. Если всё верно написано, то разработчикам надо как-то и это описать для ясности (почему не берём 1. А берем только цифры после точки и где хранится часть до точки)
Ira Tsygarova
36 уровень, Санкт-Петербург
7 мая 2020, 19:12
у них ошибка, посмотри мой комментарий выше, там подробно расписала
Вадим
16 уровень, Саранск
Expert
2 апреля 2020, 19:27
int x = (int) Math.round(4.5); //результат 5 Должно округляться до ближайшего целого. Но 4.5 середина. Почему в большую сторону округлилось? И всегда ли будет в большую округляться?
Anton Tikhonov
26 уровень, Ижевск
4 апреля 2020, 11:15
да, всегда в большую, это связано с симметрией округления от 0 до 4 в меньшую сторону, от 5 до 9 в большую