Decimal.round метод

Применения

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

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

Поля

AwayFromZero	1	Guid.tostring метод Режим округления до ближайшего числа. Когда число находится посредине между двумя другими числами, оно округляется до ближайшего к нулю числа.Round to nearest mode: when a number is halfway between two others, it is rounded toward the nearest number that is away from zero.
ToEven	Режим округления до ближайшего числа. Когда число находится посредине между двумя другими числами, оно округляется до ближайшего четного числа.Round to nearest mode: when a number is halfway between two others, it is rounded toward the nearest even number.
ToNegativeInfinity	3	Режим направленного округления. Число округляется в меньшую сторону до ближайшего результата, не большего, чем бесконечно точный результат.Directed mode: the number is rounded down, with the result closest to and no greater than the infinitely precise result.
ToPositiveInfinity	4	Режим направленного округления. Число округляется в большую сторону до ближайшего результата, не меньшего, чем бесконечно точный результат.Directed mode: the number is rounded up, with the result closest to and no less than the infinitely precise result.
ToZero	2	Режим направленного округления. Число округляется к нулю до ближайшего результата, не превышающего по порядку бесконечно точный результат.Directed mode: the number is rounded toward zero, with the result closest to and no greater in magnitude than the infinitely precise result.

Методы

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

• Округление к ближайшему целому — наиболее часто используемое округление, при котором число округляется до целого, модуль разности с которым у этого числа минимален. В общем случае, когда число в десятичной системе округляют до 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 последнего сохраняемого разряда.

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

Работающие реализации на 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(), которая корректно разделяет целую и дробную части чисел.

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

Существует несколько способов округления в зависимости от способа применения результата: округление к меньшему/ большему, округление к меньшему/ большему по модулю, округление к ближайшему целому, округление к ближайшему чётному и т. д… Округление к ближайшему целому, в свою очередь, можно делать по-разному в зависимости от того, какой результат должен получиться, если дробная часть равна 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.

Ошибка округления, вызванная арифметикой с плавающей запятой

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

Добавление

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

Например, при добавлении к двойной точности IEEE следующим образом ,
1 {\ displaystyle 1} 2 — 53 {\ displaystyle 2 ^ {- 53}}

1,00 … × 2 + 1,00 … × 2 — 53 знак равно 1. 00 … ⏟ 52 бит × 2 + 00 … ⏟ 52 бит 1 × 2 знак равно 1. 00 … ⏟ 52 бит 1 × 2 {\ displaystyle {\ begin {align} 1,00 \ ldots 0 \ times 2 ^ {0} +1,00 \ ldots 0 \ times 2 ^ {- 53} & = 1. \ underbrace {00 \ ldots 0} _ {\ text { 52 бита}} \ times 2 ^ {0} +0. \ Underbrace {00 \ ldots 0} _ {\ text {52 бит}} 1 \ times 2 ^ {0} \\ & = 1. \ underbrace {00 \ ldots 0} _ {\ text {52 бита}} 1 \ times 2 ^ {0} \ end {выровнено}}}

Это сохраняется, поскольку в стандарте IEEE используется округление до ближайшего. Поэтому, равно двойной точности IEEE и округление ошибка . 1. 00 … 0 ⏟ 52 бит × 2 0 {\ displaystyle 1. \ underbrace {00 \ ldots 0} _ {\ text {52 бит}} \ times 2 ^ {0}} 1 + 2 — 53 {\ displaystyle 1 + 2 ^ {- 53}} 1 {\ displaystyle 1} 2 — 53 {\ displaystyle 2 ^ {- 53}}

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

Умножение

Как правило, произведение мантисс с -цифрами содержит до цифр, поэтому результат может не соответствовать мантиссе. Таким образом, в результат будет включена ошибка округления.
2 {\ displaystyle 2} п {\ displaystyle p} 2 п {\ displaystyle 2p}

Например, рассмотрим нормализованную систему счисления с плавающей запятой, в которой основание и цифры мантиссы не больше . Потом и

Обратите внимание, но поскольку там не более цифр мантиссы. Ошибка округления будет

β знак равно 10 {\ displaystyle \ beta = 10} 2 {\ displaystyle 2} ж л ( 77 ) знак равно 7,7 × 10 {\ displaystyle fl (77) = 7,7 \ times 10} ж л ( 88 ) знак равно 8,8 × 10 {\ displaystyle fl (88) = 8,8 \ times 10} 77 × 88 знак равно 6776 {\ displaystyle 77 \ times 88 = 6776} ж л ( 6776 ) знак равно 6,7 × 10 3 {\ displaystyle fl (6776) = 6,7 \ times 10 ^ {3}} 2 {\ displaystyle 2} 6776 — ж л ( 6776 ) знак равно 6776 — 6,7 × 10 3 знак равно 76 {\ displaystyle 6776-fl (6776) = 6776-6,7 \ times 10 ^ {3} = 76}

Разделение

Как правило, частное мантисс-цифр может содержать больше, чем -цифров. Таким образом, в результат будет включена ошибка округления.
2 {\ displaystyle 2} п {\ displaystyle p} п {\ displaystyle p}

Например, если приведенная выше нормализованная система счисления с плавающей запятой все еще используется, то но . Итак, хвост отрезан. 1 / 3 знак равно 0,333 … {\ Displaystyle 1/3 = 0,333 \ ldots} ж л ( 1 / 3 ) знак равно ж л ( 0,333 … ) знак равно 3.3 × 10 — 1 {\ displaystyle fl (1/3) = fl (0,333 \ ldots) = 3,3 \ times 10 ^ {- 1}} 0,333 … — 3.3 × 10 — 1 знак равно 0,00333 … {\ displaystyle 0,333 \ ldots -3,3 \ times 10 ^ {- 1} = 0,00333 \ ldots}

Субтрактивная отмена

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

• Когда первые цифры отменяются, результат может быть слишком маленьким для точного представления, и он будет представлен просто как .
  {\ displaystyle 0}

  Например, let и здесь используется второе определение машинного эпсилон. Какое решение ? Известно, что и почти равны числа, и . Однако в системе счисления с плавающей запятой . Несмотря на то, что он достаточно большой, чтобы его можно было представить, оба экземпляра были округлены в виде дачи . | ϵ |

• Даже при несколько большем значении результат в типичных случаях все равно существенно ненадежен. Нет особой веры в точность значения, потому что наибольшая неопределенность в любом числе с плавающей запятой — это цифры в крайнем правом углу.
  ϵ {\ displaystyle \ epsilon}

  Например, . Результат наглядно представим, но веры в него нет. 1,99999 × 10 2 — 1,9998 × 10 2 знак равно 0,00001 × 10 2 знак равно 1 × 10 — 5 × 10 2 знак равно 1 × 10 — 3 {\ displaystyle 1.99999 \ times 10 ^ {2} -1.99998 \ times 10 ^ {2} = 0.00001 \ times 10 ^ {2} = 1 \ times 10 ^ {- 5} \ times 10 ^ {2} = 1 \ times 10 ^ {- 3}} 1 × 10 — 3 {\ displaystyle 1 \ times 10 ^ {- 3}}

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, в противном случае будет отброшена. Хитро и не очевидно до тех пор, пока мы не посмотрим глубже.

Правила округления

Коммерческое округление

В Коммерческие туры (не отрицательные числа) выглядит следующим образом :

• Если число в первом десятичном разряде равно 0, 1, 2, 3 или 4, оно округляется в меньшую сторону.
• Если число в первом десятичном разряде — 5, 6, 7, 8 или 9, то оно округляется в большую сторону.

Это правило округления описано в стандарте DIN 1333 . Округление часто уже преподается в начальной школе.

Примеры (округление до двух знаков после запятой):

• 13,3749 … € ≈ 13,37 €
• 13,3750 … € ≈ 13,38 €

Отрицательные числа в зависимости от их величины округлой формы, на 5 , чтобы сказать от нуля ( Engl : от нуля ):

• −13,3749 … € ≈ −13,37 €
• −13,3750 … € ≈ −13,38 €

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

Симметричное закругление

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

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

1. Если число в первом десятичном разряде равно 0, 1, 2, 3 или 4, оно округляется в меньшую сторону.
2. Если число представляет собой 5 (за которыми следуют другие цифры, которые не равны нулю), 6, 7, 8 или 9 в первом десятичном разряде, оно округляется в большую сторону.
3. Если цифра в первом десятичном разряде, которую следует опустить, представляет собой только 5 (или 5, за которой следуют только нули), она округляется таким образом, чтобы последняя сохраняемая цифра была четной.

Этот тип округления используется в числовой математике , инженерии и технике. Он предусмотрен стандартом IEEE 754 для вычислений с двоичными числами с плавающей запятой в компьютерах. В англоязычной литературе это называется Round to Even или Banker’s Rounding .

Примеры (округление до одного десятичного знака):

• 2,2499 ≈ 2,2 (по правилу 1)
• 2,2501 ≈ 2,3 (по правилу 2)
• 2,2500 ≈ 2,2 (округлено до четного числа согласно правилу 3)
• 2,3500 ≈ 2,4 (округлено до четного числа согласно правилу 3)

Коммерческое округление приводит к небольшим систематическим ошибкам, так как округление на 0,5 происходит в большую сторону, а в меньшую сторону на 0,5 никогда не происходит; это может немного исказить статистику. Математическое округление всегда округляется в большую или меньшую сторону от точной середины между двумя цифрами до следующей четной цифры. В результате среднее значение округляется вверх и вниз примерно так же часто, по крайней мере, если исходные числа являются стохастическими . (Контрпример: если маленькие числа встречаются чаще, чем большие, их можно систематически округлять в меньшую сторону, чем в большую, см . Закон Бенфорда .)

Округление с сохранением суммы

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

Важными приложениями являются распределение мест в пропорциональном представительстве и распределение всего НДС в счете-фактуре по его отдельным позициям.

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

Метод Харе-Нимейера может быть обобщен для слагаемых с обоими знаками : вы округляете все числа до ближайших круглых чисел, и пока сумма слишком велика (или слишком мала), вы выбираете одно из округленных (или округленных) чисел. ) нумерует с наибольшим округление (или самое большое количество округления вниз) и изменяет его округления в направлении , противоположном. Это означает, что сумма изменений минимальна .

Различие округления в 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 (значения возводятся к близкому четному). Минимизировать погрешности можно благодаря практически равной вероятности, что перед пятеркой будет четное или нечетное число.

Метод Math.round() java

При использовании метода Math.round() можно контролировать п-количество десятичных разрядов путем умножения и деления на 10^п :

public static double roundAvoid(double value, int places) {
    double scale = Math.pow(10, places);
    return Math.round(value * scale) / scale;
}

Этот метод не рекомендуется использовать для округления чисел, поскольку он усекает значение. Во многих случаях значения округляются неправильно:

System.out.println(roundAvoid(1000.0d, 17));
// Вывод: 92.23372036854776 !!
System.out.println(roundAvoid(260.775d, 2));
// Вывод: 260.77 вместо ожидаемого 260.78

Эмпирические правила арифметики с округлениями

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

Все исходные значения округляются до реальной точности измерений и записываются с соответствующим числом значащих цифр, так, чтобы в десятичной записи все цифры были надёжными (допускается, чтобы последняя цифра была сомнительной). При необходимости значения записываются со значащими правыми нулями, чтобы в записи указывалось реальное число надёжных знаков (например, если длина в 1 м реально измерена с точностью до сантиметров, записывается «1,00 м», чтобы было видно, что в записи надёжны два знака после запятой), или точность явно указывается (например, 2500±5 м — здесь надёжными являются только десятки, до них и следует округлять).
Промежуточные значения округляются с одной «запасной» цифрой.
При сложении и вычитании результат округляется до последнего десятичного знака наименее точного из параметров (например, при вычислении значения 1,00 м + 1,5 м + 0,075 м результат округляется до десятых метра, то есть до 2,6 м). При этом рекомендуется выполнять вычисления в таком порядке, чтобы избегать вычитания близких по величине чисел и производить действия над числами по возможности в порядке возрастания их модулей.
При умножении и делении результат округляется до наименьшего числа значащих цифр, которое имеют множители или делимое и делитель

Например, если тело при равномерном движении прошло дистанцию 2,5⋅103 метров за 635 секунд, то при вычислении скорости результат должен быть округлён до 3,9 м/с, поскольку одно из чисел (расстояние) известно лишь с точностью до двух значащих цифр.

Важное замечание: если один операндов при умножении или делитель при делении является по смыслу целым числом (то есть не результатом измерений непрерывной физической величины с точностью до целых единиц, а, например, количеством или просто целой константой), то количество значащих цифр в нём на точность результата операции не влияет, и оставляемое число цифр определяется только вторым операндом. Например, кинетическая энергия тела массой 0,325 кг, движущегося со скоростью 5,2 м/с, равна Ek=mv22=0.325⋅5.222=4.394≈4.4{\displaystyle E_{k}={\tfrac {mv^{2}}{2}}={\tfrac {0.325\cdot 5.2^{2}}{2}}=4.394\approx 4.4} Дж — округляется до двух знаков (по количеству значащих цифр в значении скорости), а не до одного (делитель 2 в формуле), так как значение 2 по смыслу — целая константа формулы, она является абсолютно точной и не влияет на точность вычислений (формально такой операнд можно считать «измеренным с бесконечным числом значащих цифр»).

При возведении в степень в результате вычисления следует оставлять столько значащих цифр, сколько их имеет основание степени.
При извлечении корня любой степени из приближённого числа в результате следует брать столько значащих цифр, сколько их имеет подкоренное число.
При вычислении значения функции f(x){\displaystyle f\left(x\right)} требуется оценить значение модуля производной этой функции в окрестности точки вычисления

Если |f′(x)|⩽1{\displaystyle \left|f’\left(x\right)\right|\leqslant 1}, то результат функции точен до того же десятичного разряда, что и аргумент. В противном случае результат содержит меньше точных десятичных разрядов на величину log10⁡(|f′(x)|){\displaystyle \log _{10}\left(\left|f’\left(x\right)\right|\right)}, округлённую до целого в большую сторону.

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

Как округлить с помощью функции Excel?

А теперь перейдем непосредственно к практике. Что нужно делать, чтобы осуществить округление чисел с помощью функции? Для этого существует специальная функция ОКРУГЛ. Ее можно вызвать разными способами: через ленту в Excel 2007 версии и более новые.

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

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

Синтаксис функции ОКРУГЛ

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

В случае с функцией ОКРУГЛ их два. Давайте рассмотрим их более подробно.

Аргументы функции ОКРУГЛ

Итак, функция предусматривает два аргумента:

1. Число. Сюда указывается ссылка на ячейку. Или же можно ввести требуемое значение в этот аргумент вручную.

2. Количество знаков, на какое собираетесь осуществить округление.

Чтобы округлить целое число (то есть, которое не имеет ни одного знака после запятой), просто напишите знак минуса перед числом во втором параметре. Для округления до десятков, необходимо написать -1, до сотен – -2, и по такой логике далее. Чем больше модуль этого числа, тем на большее количество цифр будет осуществляться округление. 

Основы использования функции ОКРУГЛ

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

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

4

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

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

5

По кратности

Excel дает возможность осуществлять округление чисел не до самого ближнего, а до того, которое является кратным по отношению к определенному. Для этого существует специальная функция, которая называется ОКРУГЛТ. С ее помощью можно добиться необходимой точности округления. 

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

По количеству знаков

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