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

Как проверить, активирована ли Windows 10?

Округление чисел

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

Слово «округление» говорит само за себя. Округлить число значит сделать его круглым. Круглым называется число, которое оканчивается нулём. Например, следующие числа являются круглыми:

10, 20, 30, 100, 300, 700, 1000

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

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

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

Рассмотрим простой пример на округление. Дано число 17. Требуется округлить его до разряда десятков.

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

Предстáвим числа от 10 до 20 с помощью следующего рисунка:

На рисунке видно, что для числá 17 ближайшее круглое число это число 20. Значит ответ к задаче таким и будет: «17 приближённо равно 20″

17 ≈ 20

Мы нашли приближённое значение для 17, то есть округлили его до разряда десятков. Видно, что после округления в разряде десятков появилась новая цифра 2.

Попробуем найти приближённое число для числа 12. Для этого снова предстáвим числа от 10 до 20 с помощью рисунка:

На рисунке видно, что ближайшее круглое число для 12 это число 10. Значит ответ к задаче таким и будет: 12 приближённо равно 10

12 ≈ 10

Мы нашли приближённое значение для 12, то есть округлили его до разряда десятков. В этот раз цифра 1, которая стояла в разряде десятков в числе 12, не пострадала от округления. Почему так получилось мы расскажем позже.

Попробуем найти ближайшее число для числá 15. Снова предстáвим числа от 10 до 20 с помощью рисунка:

На рисунке видно, что число 15 одинаково удалено от круглых чисел 10 и 20. Возникает вопрос: которое из этих круглых чисел будет приближённым значением для числа 15? Для таких случаев условились принимать бóльшее число за приближённое. 20 больше чем 10, поэтому приближённое значение для 15 будет число 20

15 ≈ 20

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

Итак, мы должны округлить 1456 до разряда десятков. Разряд десятков начинается на пятёрке:

Теперь о существовании первых цифр 1 и 4 временно забываем. Остается число 56

Теперь смотрим, какое круглое число находится ближе к числу 56. Очевидно, что ближайшее круглое число для 56 это число 60. Значит заменяем число 56 на число 60

Значит при округлении числа 1456 до разряда десятков полýчим 1460

1456 ≈ 1460

Видно, что после округления числа 1456 до разряда десятков, изменения коснулись и самогó разряда десятков. В новом полученном числе в разряде десятков теперь располагается цифра 6, а не 5.

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

После того, как станóвится ясно, что округление это ни что иное как поиск ближáйшего числá, можно применять готовые правила, которые значительно облегчают округление чисел.

Применения

Округление используется для того, чтобы работать с числами в пределах того количества знаков, которое соответствует реальной точности параметров вычислений (если эти значения представляют собой измеренные тем или иным образом реальные величины), реально достижимой точности вычислений либо желаемой точности результата. В прошлом округление промежуточных значений и результата имело прикладное значение (так как при расчётах на бумаге или с помощью примитивных устройств типа абака учёт лишних десятичных знаков может серьёзно увеличить объём работы). Сейчас оно остаётся элементом научной и инженерной культуры. В бухгалтерских приложениях, кроме того, использование округлений, в том числе промежуточных, может требоваться для защиты от вычислительных ошибок, связанных с конечной разрядностью вычислительных устройств.

Более того, некоторые исследования используют округления возраста для измерения числовой грамотности. Это связано с фактом, что менее образованные люди склонны округлять свой возраст вместо того, что бы указывать точный. Например, в официальных записях населения с более низким уровнем человеческого капитала чаще встречается возраст 30, чем 31 или 29.

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

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

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

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

Round() в Go 1.10

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

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

Рассматривая приведённые выше константы, мы видим, что сдвиг составляет 64 — 11 — 1, что означает 64 бита на число, 11 из которых используются для показателя степени, один — для знака и 52 оставшихся бита — для мантиссы. Это означает, что используемый сдвиг удаляет биты мантиссы, а маска удаляет бит знака, оставляя нас только с показателем степени.

В полученном числе показатель степени записан не как он есть, а с прибавлением числа 1023 (это делается для того чтобы записывать отрицательные показатели для очень маленьких чисел), что означает, что мы должны вычесть 1023 из e, вычисленного выше, чтобы получить фактический показатель. Иными словами, если e < bias, то мы имеем отрицательный показатель степени, что означает, что абсолютное значение float должно быть < 1. Действительно, дальше мы видим:

Здесь бит маскируется знаковым битом, это используется только для сохранения правильного знака: теперь мы можем полностью игнорировать мантиссу. Мы можем это сделать, потому что в этом случае нас интересует только показатель степени. Так как используется основание степени 2, а e < bias, мы знаем, что наименьший показатель, который может быть, равен -1, а 2 ^ -1 = 0,5. Кроме того, мантисса имеет некоторое значение 1.X. Таким образом, в зависимости от показателя наше число находится либо в диапазоне (0,5, 1), либо в диапазоне (0, 0,5). Поэтому во втором случае для правильного округления нам нужно добавить к числу единицу. Фух. Подробнее это описано в википедии.

Теперь разберём второй случай:

Наверное, вы думаете, что условие в этой ветке должно быть e > bias, чтобы покрыть все случаи с положительным показателем степени. Но вместо этого тут используется только их часть. Использование сдвига здесь особенно интересно, потому что кажется, что оно несравнимо с bias. Первое — это число битов смещения, а второе — численное смещение. Но, поскольку числа с плавающей точкой представлены как (1.мантисса) * 2 ^ X, то если X больше числа битов в мантиссе, мы гарантированно получим значение без дробной части. То есть показатель степени сместил десятичную точку вправо настолько, что мантисса окончательно пропала. Таким образом, выражение в этой ветке игнорирует числа с плавающей точкой, которые уже округлены.

Первая строка тут простая: вычитаем bias из e и получаем реальное значение показателя степени. Вторая строка добавляет к значению 0,5. Это работает, потому что старший бит мантиссы добавляет 0,5 к финальной сумме (см. представление в статье “Википедии” ниже). В этом случае эта сумма переполняет 52-битные границы мантиссы, показатель степени будет увеличен на 1. Значение показателя степени не сможет переполниться до знакового бита, так как оно не может быть больше bias+shift из примера выше. В любом случае, дробная часть очищается. Таким образом, если дробная часть была больше или равна 0,5, она будет увеличена на 1, в противном случае будет отброшена. Хитро и не очевидно до тех пор, пока мы не посмотрим глубже.

Встроенные функции

Для операции округления в Python есть встроенные функции – и

round

– округляет число (number) до ndigits знаков после запятой. Это стандартная функция, которая для выполнения не требует подключения модуля math.

По умолчанию операция проводится до нуля знаков – до ближайшего целого числа. Например:

Чтобы получить целый показатель, результат преобразовывают в .

Синтаксически функция вызывается двумя способами.

1. – это округление числа до целого, которое расположено ближе всего. Если дробная часть равна 0,5, то округляют до ближайшего четного значения.
2. – данные округляют до знаков после точки. Если округление проходит до сотых, то равен «2», если до тысячных – «3» и т.д.

int

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

Для положительных чисел функция аналогична функции , а для отрицательных – аналогично . Например:

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

1. Если число положительное, добавить к нему 0,5.
2. Если число отрицательное, добавить -0,5.

Синтаксически преобразование оформляется так:

toString(base)

Метод возвращает строковое представление числа в системе счисления .

Например:

может варьироваться от до (по умолчанию ).

Часто используемые:

• base=16 — для шестнадцатеричного представления цвета, кодировки символов и т.д., цифры могут быть или .

• base=2 — обычно используется для отладки побитовых операций, цифры или .

• base=36 — максимальное основание, цифры могут быть или . То есть, используется весь латинский алфавит для представления числа. Забавно, но можно использовать -разрядную систему счисления для получения короткого представления большого числового идентификатора. К примеру, для создания короткой ссылки. Для этого просто преобразуем его в -разрядную систему счисления:

Две точки для вызова метода

Внимание! Две точки в это не опечатка. Если нам надо вызвать метод непосредственно на числе, как в примере выше, то нам надо поставить две точки после числа

Если мы поставим одну точку: , тогда это будет ошибкой, поскольку синтаксис JavaScript предполагает, что после первой точки начинается десятичная часть. А если поставить две точки, то JavaScript понимает, что десятичная часть отсутствует, и начинается метод.

Также можно записать как .

АргументыArguments

numeric_expressionnumeric_expressionВыражение категории точного числового или приблизительного числового типа данных, за исключением типа данных bit.Is an expression of the exact numeric or approximate numeric data type category, except for the bit data type.

lengthlengthТочность, с которой должно быть округлено значение numeric_expression.Is the precision to which numeric_expression is to be rounded. Аргумент length должен быть выражением типа tinyint, smallint или int. Если аргумент length является положительным числом, значение numeric_expression округляется до числа десятичных разрядов, указанных в аргументе length.length must be an expression of type tinyint, smallint, or int. When length is a positive number, numeric_expression is rounded to the number of decimal positions specified by length. Если аргумент length является отрицательным числом, значение numeric_expression округляется слева от десятичной запятой, как указано в аргументе length.When length is a negative number, numeric_expression is rounded on the left side of the decimal point, as specified by length.

functionfunctionТип выполняемой операции.Is the type of operation to perform. Аргумент function должен иметь тип tinyint, smallint или int. Если аргумент function не указан или имеет значение 0 (по умолчанию), значение numeric_expression округляется.function must be tinyint, smallint, or int. When function is omitted or has a value of 0 (default), numeric_expression is rounded. Когда указывается значение, не равное 0, значение numeric_expression усекается.When a value other than 0 is specified, numeric_expression is truncated.

Методы

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

• Округление к ближайшему целому (англ. rounding) — наиболее часто используемое округление, при котором число округляется до целого, модуль разности с которым у этого числа минимален. В общем случае, когда число в десятичной системе округляют до N-го знака, правило может быть сформулировано следующим образом:
  • если N+1 знак < 5, то N-й знак сохраняют, а N+1 и все последующие обнуляют;
  • если N+1 знак ≥ 5, то N-й знак увеличивают на единицу, а N+1 и все последующие обнуляют;

  Например: 11,9 → 12; −0,9 → −1; −1,1 → −1; 2,5 → 3.

  Максимальная дополнительная абсолютная погрешность, вносимая при таком округлении (погрешность округления), составляет ±0,5 последнего сохраняемого разряда.

• Округление к меньшему по модулю (округление к нулю, целое англ. fix, truncate, integer) — самое «простое» округление, поскольку после обнуления «лишних» знаков предшествующий знак сохраняют, то есть технически оно состоит в отбрасывании лишних знаков. Например, 11,9 → 11; −0,9 → 0; −1,1 → −1). При таком округлении может вноситься погрешность в пределах единицы последнего сохраняемого разряда, причём в положительной части числовой оси погрешность всегда отрицательна, а в отрицательной — положительна.
• Округление к большему (округление к +∞, округление вверх, англ. ceiling — досл. «потолок») — если обнуляемые знаки не равны нулю, предшествующий знак увеличивают на единицу, если число положительное, или сохраняют, если число отрицательное. В экономическом жаргоне — округление в пользу продавца, кредитора (лица, получающего деньги). В частности, 2,6 → 3, −2,6 → −2. Погрешность округления — в пределах +1 последнего сохраняемого разряда.
• Округление к меньшему (округление к −∞, округление вниз, англ. floor — досл. «пол») — если обнуляемые знаки не равны нулю, предшествующий знак сохраняют, если число положительное, или увеличивают на единицу, если число отрицательное. В экономическом жаргоне — округление в пользу покупателя, дебитора (лица, отдающего деньги). Здесь 2,6 → 2, −2,6 → −3. Погрешность округления — в пределах −1 последнего сохраняемого разряда.
• Округление к большему по модулю (округление к бесконечности, округление от нуля) — относительно редко используемая форма округления. Если обнуляемые знаки не равны нулю, предшествующий знак увеличивают на единицу. Погрешность округления составляет +1 последнего разряда для положительных и −1 последнего разряда для отрицательных чисел.

Ошибки плавающей запятой

Дробные величины компьютер обычно трактует как числа с плавающей точкой. Аксессовские поля типов Двойной точности (Double) или Одинарной точности (Single) относятся к такому типу. Тип «Двойной точности» дает около 15 знаков точности, сингл — 8 знаков (подобно ручному калькулятору).

Но эти числа являются приблизительными. Точно так же, как 1/3 требует бесконечного количества знаков в десятичной системе, большинство чисел с плавающей запятой не могут быть представлены точно в двоичной системе. Википедия объясняет , с которой вы сталкиваетесь, оперируя числами с плавающей запятой.

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

Один из способов избежать подобных проблем — использовать числа с фиксированной запятой или мастшабированные числа.Тип данных «Денежный» в Аксессе является типом с фиксированной запятой: он всегда хранит 4 десятичных знака.

Например, откройте окно Immediate Window (Ctrl+G) и введите:    ? Round(CCur(.545),2), Round(CDbl(.545),2) Денежный тип (первый) возвращает 0,54, тогда как Двойной точности — 0,55. Денежный округляет корректно (к четной цифре 4); тип с плавающей запятой (Двойной точности) некорректно. Подобным образом, если вы попробуете 8,995, Денежный корректно округлит вверх (к четной цифре 0), в то время как тип Двойной точности округлит вниз (неверно.)

Денежный тип справляется только с 4 десятичными знаками. Используйте масштабируемый тип Действительный (Decimal), если вам нужно больше знаков после запятой.

Различие округления в Python 2 и Python 3

В Python 2 и Python 3 реализованы разные принципы округления.

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

Во втором Python есть только 4 цифры, которые ведут к преобразованию к меньшему значению – 1, 2, 3 и 4. Также 5 цифр, которые приводят к большему значению – 5, 6, 7, 8, 9. Такое неравное распределение ведет к тому, что погрешность постоянно нарастает.

Python 2 по правилам арифметического округления преобразует число 5,685 в 5,68 до второго знака. Такая погрешность связана с тем, что десятичные цифры float в двоичном коде невозможно корректно представить.

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

2,5 по правилам банковского преобразования будет равно 2, а 3,5 = 4 (значения возводятся к близкому четному). Минимизировать погрешности можно благодаря практически равной вероятности, что перед пятеркой будет четное или нечетное число.

Работающие реализации на Go

Round(), используемая в Postgres

Выше я уже упоминал, что в Postgres содержится код функции Round() на C, который работает для всех тестируемых значений. В CockroachDB мы , без комментариев он выглядит следующим образом:

Давайте разберёмся, как он работает. Первые шесть строк обрабатывают особые случаи. Далее мы выбираем roundFn из Ceil и Floor в зависимости от того, положительное число или отрицательное. Далее начинается самое интересное:

Этим кодом мы сдвигаем x ближе к нулю.

Далее мы проверяем, не стал ли x в точности нулём и не поменялся ли у него знак. Это означает что исходное число <= 0,5, в этом случае мы возвращаем ноль с нужным знаком.

Эта проверка нужна для очень больших чисел, для которых x-0,5 == x-1,0, в этих случаях мы можем вернуть число неизменённым.

Далее мы округляем число с помощью Floor() или Ceil() и возвращаем это значение, если оно отличается от x, что может случиться, только если дробная часть входного значения не равна в точности 0,5, так как выше мы вычли 0,5 из него.

Теперь мы знаем, что дробная часть равна 0,5, поэтому нам нужно округлить до ближайшего чётного числа (реализация Round() в Postgres в этом месте отличается от приведённых выше вариантов). Комментарий в коде лучше это описывает:

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

github.com/montanaflynn/stats

Ещё одна работающая реализация содержится в пакете github.com/montanaflynn/stats. Без комментариев она выглядит следующим образом:

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

Округлить до 1000 руб.

Функция Round() в Excel принимает отрицательные числа в качестве количества мест от запятой, напр. Round(123456, -3) округляет до 1000. К сожалению, аксессовская функция этого не поддерживает.

Чтобы округлить до ближайших 1000 руб., разделите на 1000, округлите, и умножьте на 1000. Пример:    1000 * Round( / 1000, 0)

Чтобы округлить до 1000 руб. вниз, разделите на 1000, получите целое число и умножьте на 1000. Пример:    1000 * Int( / 1000)

Чтобы округлить до верхней 1000 руб., разделите на 1000 и умножьте на -1 перед получением целой величины. Пример:    -1000 * Int( / -1000)

Чтобы округлить в сторону нуля, используйте Fix() вместо Int().

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

Выбор способа округления

Существует несколько способов округления в зависимости от способа применения результата: округление к меньшему/ большему, округление к меньшему/ большему по модулю, округление к ближайшему целому, округление к ближайшему чётному и т. д… Округление к ближайшему целому, в свою очередь, можно делать по-разному в зависимости от того, какой результат должен получиться, если дробная часть равна 0,5. Я буду рассматривать округление к ближайшему целому, причём 0,5 будет округляться в большую (по модулю) сторону.

Требования к корректной реализации Round() заключаются в следующем:

• правильно округляет до ближайшего целого все конечные числа;
• поддерживает специальные значения (NaN, Inf, -0), возвращая их без изменений.

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

В этом списке есть обычные числа, специальные значения и некоторые граничные случаи, с которыми простым алгоритмам сложно справиться

Обратите внимание, что, поскольку мы используем float, мы не можем использовать число 0,49999999999999999 в качестве ближайшего к 0,5, так как из-за ограниченной точности float это число в точности равно 0,5. Вместо этого я использую 0,49999999999999994

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

int(f + 0.5)

Первая реализация, предложенная rsc, выглядела следующим образом:

Она некорректно работает с особыми значениями, отрицательными числами, числами больше math.MaxInt64 и числами, близкими к 0,5:

Floor() or Ceil()

Второй предложенный вариант учитывал отрицательные числа:

однако продолжал некорректно работать в некоторых случаях:

Первые два теста не проходят, потому что результат разности n — 0,5 равен в точности -1,0, тогда как мы ожидаем получить что-то точно большее, чем -1,0. Если посмотреть на , можно понять, как решить эту проблему.

Самое интересное, что эта ошибка не является такой уж редкой. До версии 6 точно такая же присутствовала в Java. Хорошо, что с тех пор реализация улучшилась.

int и Copysign

В третьем предложении от minux была предпринята другая попытка решить проблему отрицательных чисел:

И этот вариант всё равно ломает тесты:

Как видно, часть тестов стала проходить, однако другие начали падать. Была предпринята попытка улучшить этот алгоритм:

Однако и она провалилась:

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

Мы рассмотрели уже четыре варианта, и в каждом из них нашлись изъяны. Настало время посмотреть, как Round() реализуют авторы различных пакетов.

Kubernetes

Kubernetes 1.7 содержит реализацию:

Она ломает следующие тесты:

Судя по тому, что функция возвращает int32, она не предназначена для работы с большими числами. Однако она некорректно работает и с числами, которые близки к 0,5.

Заключение

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

Думаю, команда Go приняла правильное решение, добавив функцию Round() в стандартную библиотеку. Без этого мы бы продолжали пользоваться различными некорректными реализациями.

Надеюсь, теперь вам стало ясно, что при работе с float есть много подводных камней, про которые порой забывают даже эксперты. Легко придумать или скопировать откуда-то однострочную реализацию, но сложно написать действительно корректную. Неудивительно, что корректно работающее округление появилось лишь в шестой мажорной версии Java (через 15 лет, прошедших с релиза Java 1.0 до выхода Java 7), и я рад, что Go прошёл этот путь быстрее.

Итого

Чтобы писать числа с большим количеством нулей:

• Используйте краткую форму записи чисел – , с указанным количеством нулей. Например: это с 6-ю нулями .
• Отрицательное число после приводит к делению числа на 1 с указанным количеством нулей. Например: это ( миллионных).

Для других систем счисления:

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

Для преобразования значений типа и в число:

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

Для дробей:

• Используйте округления , , , или .
• Помните, что при работе с дробями происходит потеря точности.

Ещё больше математических функций:

Документация по объекту Math

Библиотека маленькая, но содержит всё самое важное