Округлить в большую сторону php: PHP: number_format — Manual

Содержание

Округление до 0.5 PHP — Блог веб-разработчика

  • 11 204
  • Комментарии: 6

Часто бывают случаи, когда необходимо округлить число не до целого, а до половины целого. Например, 1,3 нужно округлить до 1.5. Такое случается редко, но всё же бывают случаи когда может понадобиться именно такое округление, в частности, я столкнулся с этим, когда мне нужно было вывести рейтинг в виде звёздочек с шагом 0.5, а данные хранились с шагом 0.1. Следующий код поможет вам округлить число до 0.5


/**
* Округление числа до 0.5. Например, если 1.2, то округлится до 1
* Если 1.5 то ничего не произойдёт, а если 1.6 то до 2
* @param $x
* @return float
*/
function roundToHalf($x)
{
    return ceil($x/0.5)*0.5;
}

echo roundToHalf(1.2) // Выведет 1
echo roundToHalf(1.1) // Выведет 1
echo roundToHalf(1.9) // Выведет 2

Как это работает?

Допустим, нам надо округлить 1.3 до 1.5. Для этого делаем следующее:

  1. 1.3 делим на 0.5, получаем: 1.3/0.5 = 2.6
  2. Округляем 2.6 до 3 (всегда округляем в большую сторону)
  3. Умножаем 3 на 0.5, получаем: 3*0.5 = 1.5
  4. Результат: 1.5

Понравилась статья? Оцени её!

Здравствуй дорогой читатель! Я рад приветствовать тебя на страницах моего блога. Уже несколько лет я занимаюсь веб-программированием и рад поделиться с тобой своими знаниями и советами. Если тебе понравились мои статьи, ты можешь подписаться на рассылку блога, из неё ты узнаешь много интересного!

Ruby как округлить только выше?



Как я могу округлить в ruby только выше, и так, чтобы 2 последних числа были null? Например

4233.000001 to 4300
52825 to 52900
627444 to 627500
111999 to 112000
?

Теперь я могу округлить только в математических правилах через раунд (-2), но как сделать только выше, и только с 2 null-ми на конце?

ruby-on-rails ruby rounding
Поделиться Источник byCoder     11 декабря 2012 в 20:57

2 ответа


  • ruby округлить до двух знаков после запятой и оставить ноль

    я хочу округлить число до двух знаков после запятой в ruby таким образом, чтобы (0.02 * 270187).round(2) — это 5403.74, что правильно но (0.02 * 278290).round(2) — это 5565.8, что не согласуется с предыдущим я хочу, чтобы это выглядело как 5565.80 Пожалуйста, скажите мне, как я могу сделать это в…

  • Округлить вверх, а не вниз, когда ниже нуля

    Похоже, что Ruby предпочитает округлять отрицательные числа вниз, а не приближать их к нулю. -1.5.round #=>-2 В то время как положительные числа работают наоборот: 2.5.round #=>3 Как округлить отрицательные числа (ближе к нулю) вместо того, чтобы округлять их вниз? Я использую ruby версию…



6

Вы должны использовать ceil

def my_round a
  (a / 100.0).ceil * 100
end

my_round 4233.000001 # => 4300
my_round 52825 # => 52900
my_round 627444 # => 627500
my_round 111999 # => 112000

Поделиться Sergio Tulentsev     11 декабря 2012 в 21:00



3

работая над ответом Серджио, вы можете смешать модуль с фактическим объектом Numeric для более общего решения:

module RoundsUp
  def round_up(ndigits)
    pow_ten = 10 ** -ndigits
    (self / pow_ten.to_f).ceil * pow_ten
  end
end

затем

mynumeric = 262.33
mynumeric.extend(RoundsUp)
mynumeric.round_up(-2) #=> 300

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

Поделиться hdgarrood     11 декабря 2012 в 21:17


Похожие вопросы:


Округлить до ближайшей десятой?

Мне нужно округлить до ближайшей десятой. Мне нужно ceil , но с точностью до первого десятичного знака. Примеры: 10.38 would be 10.4 10.31 would be 10.4 10.4 would be 10.4 Поэтому, если это какая-то…


Как округлить числа до динамической точности в Ruby на Rails?

Я хочу округлить числа до их ближайшего порядка. (Я думаю, что сказал это правильно) Вот несколько примеров: Input => Output 8 => 10 34 => 40 99 => 100 120 => 200 360 => 400 990…


Как округлить следующее или Предыдущее значение

Я пытаюсь округлить Quantity , пока клиент добавляет товар в корзину. Здесь я немного запутался, как мы можем это сделать. Например, продукт имеет уровень price qty , например 10. Если клиент…


ruby округлить до двух знаков после запятой и оставить ноль

я хочу округлить число до двух знаков после запятой в ruby таким образом, чтобы (0.02 * 270187).round(2) — это 5403.74, что правильно но (0.02 * 278290).round(2) — это 5565.8, что не согласуется с…


Округлить вверх, а не вниз, когда ниже нуля

Похоже, что Ruby предпочитает округлять отрицательные числа вниз, а не приближать их к нулю. -1.5.round #=>-2 В то время как положительные числа работают наоборот: 2.5.round #=>3 Как округлить…


Как округлить цены с помощью PHP

я хочу округлить цены в PHP например, у меня есть цена £74.32 , которую я хочу округлить до шкафа 5.00 , или если выше 5, то 9.00 , а десятичные дроби я всегда хочу быть .95 .. Например £74.32 would…


Ruby — как округлить Unix Timestamp (эпоха) до ближайшего месяца

Я пытаюсь округлить UNIX временных меток в Ruby до ближайшего целого месяца. У меня есть следующие временные метки UNIX, которые я хотел бы преобразовать, как показано на рисунке-в основном, если…


Как округлить входную переменную до определенного числа

Я использую python 3+ и хочу округлить переменную до 500, а если вход выше 500, то она округляется до 1000. Есть ли способ, которым я мог бы math.ceil() или round() ? Я делал это до сих пор, но я не…


Как округлить на » интервал»

Пусть VetA = c(3.12,3.13,3.23,3.29,3.46) , и я хочу округлить его на интервал 0.05 . Решение может быть: round(vetA/5,digits = 2)*5) Что даст мне c(3.1, 3.15, 3.25, 3.3, 3.45) . Однако что, если мое…


Как округлить число в файле шаблона angularjs

В файле шаблона angularjs html мне нужно округлить число (например, от 5.12 до 6). <td>{{number| currency:$:0}}</td> Я попробовал это сделать: number.ceil а также попробовал решения из…

Функции PHP: округление в меньшую сторону

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

Необходимость и варианты округления

Причины для округления чисел могут быть самые разные. Самая востребованная — формирование численных атрибутов для стилей и правил CSS.

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

Базовые варианты округления в любом языке ограничиваются тремя функциями: математическое, в меньшую или большую сторону.

На PHP программирование также располагает тремя функциями для операций округления: round(), floor() и ceil().

Программирование (в общем смысле) предлагает умножать исходное число на степень числа 10 (10, 100, 1000, 10000 и т. д.) для выполнения функции округления в нужной позиции числа. В отношении функции round() это свойство не имеет значения (у нее есть необязательный второй параметр, которым можно определить позицию округления).

Пример округления чисел в PHP

В данном примере приведено классическое округление одного и того же числа всеми тремя базовыми функциями и предложен вариант округления, который допускает строчная семантика языка. Число — это тоже строка символов. Просто ее алфавит ограничен десятью цифрами, точкой и знаками «+» и «-«. Если рассматривать экспоненциальное представление, то там еще есть буква E.

В отношении первого числа (1) значение round() совпадает с ceil(), в отношении второго числа (2) совпадают результаты round() и floor(). Идеальное PHP округление в меньшую сторону предлагает вариант (3).

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

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

Функции PHP: округление в меньшую сторону

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

Необходимость и варианты округления

Причины для округления чисел могут быть самые разные. Самая востребованная — формирование численных атрибутов для стилей и правил CSS.

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

Базовые варианты округления в любом языке ограничиваются тремя функциями: математическое, в меньшую или большую сторону.

На PHP программирование также располагает тремя функциями для операций округления: round(), floor() и ceil().

Программирование (в общем смысле) предлагает умножать исходное число на степень числа 10 (10, 100, 1000, 10000 и т. д.) для выполнения функции округления в нужной позиции числа. В отношении функции round() это свойство не имеет значения (у нее есть необязательный второй параметр, которым можно определить позицию округления).

Пример округления чисел в PHP

В данном примере приведено классическое округление одного и того же числа всеми тремя базовыми функциями и предложен вариант округления, который допускает строчная семантика языка. Число — это тоже строка символов. Просто ее алфавит ограничен десятью цифрами, точкой и знаками «+» и «-«. Если рассматривать экспоненциальное представление, то там еще есть буква E.

В отношении первого числа (1) значение round() совпадает с ceil(), в отношении второго числа (2) совпадают результаты round() и floor(). Идеальное PHP округление в меньшую сторону предлагает вариант (3).

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

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

округление и другие действия с дробными числами

Функция SQL ROUND(результат_вычислений, n) округляет результат вычислений до n-го знака после запятой. Округление производится по правилам арифметики.

Если n — отрицательное число (−n), то округление происходит до n-го знака перед запятой. Таким образом, с помощью функции ROUND можно получить и целое число как результат округления.

Пример 1. В базе данных фирмы есть таблица Staff, содержащая данные о сотрудниках фирмы. Выведем индивидуальные размеры заработной платы сотрудников:

SELECT Name, Salary FROM STAFF

Результатом выполнения запроса будет следующая таблица:

NameSalary
Sanders18357.5
Pernal15430.0
Marenghi17506.8
Doctor12322.8
Factor16228.7
Junkers16232.8
Moonlight21500.6
Aisen19540.7
MacGregor15790.8

Для вычисления среднего размера заработной платы пишем запрос:

SELECT AVG(Salary) FROM STAFF

Получим следующий результат:

AVG(Salary)
16990.06662326389

Для отчётов результат с таким числом знаков после запятой не годится. Округлим результат до второго знака после запятой с помощью функции ROUND:

SELECT ROUND(AVG(Salary),2) AS Avg_Salary FROM STAFF

Результат будет следующим:

Пример 2. Теперь округлим результат до первого знака до запятой, применяя в функции ROUND параметр минус единица:

SELECT ROUND(AVG(Salary),−1) AS Avg_Salary FROM STAFF

Результат будет следующим:

Сместим округление ещё на один знак влево и применим в функции ROUND параметр минус 2:

SELECT ROUND(AVG(Salary),−2) AS Avg_Salary FROM STAFF

Результат будет следующим:

Функция SQL ROUND может применяться ещё и с третьим необязательными параметром (кроме MySQL). Если этим параметром будет 1, то округление производиться не будет, просто в результате будет оставлено столько знаков после запятой, сколько указано во втором параметре.

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

SELECT ROUND(AVG(Salary),2,1) AS Avg_Salary FROM STAFF

Результат будет следующим:

Функция MySQL TRUNCATE

В MySQL аналогом разновидности функции ROUND без округления результата является функция TRUNCATE. Она, как и ROUND в общем случае имеет два параметра: результат вычислений и число знаков после запятой.

Пример 4. Условие то же, что в примере 3, но в MySQL. Применяем функцию TRUNCATE:

SELECT TRUNCATE(AVG(Salary),2) AS Avg_Salary FROM STAFF

Получим результат без округления, как в предыдущем примере:

Функция SQL CEILING не производит округления. Она просто принимает дробное число и возвращает максимальное целое число, не меньшее принятого. Приведём примеры действия функции с различными принятыми дробными числами.

Функция с аргументомВозвращаемое значение
CEILING(0.38)1
CEILING(1.63)2
CEILING(−0.38)0
CEILING(−1.63)−1

В случае функции CEILING некорректно говорить об округлении, поскольку она преобразует числа без учёта правил арифметики.

Функция FLOOR также не производит округления. Её действие противоположно действию функции CEILING. Она принимает дробное число и возвращает максимальное целое число, не большее принятого. Приведём примеры действия функции с различными принятыми дробными числами.

Функция с аргументомВозвращаемое значение
FLOOR(0.38)0
FLOOR(1.63)1
FLOOR(−0.38)−1
FLOOR(−1.63)−2

Функция FLOOR, как и функция CEILING, преобразует числа без учёта правил арифметики.

Поделиться с друзьями

Реляционные базы данных и язык SQL

Python | Модуль decimal

Модуль decimal

Последнее обновление: 02.05.2017

При работе с числами с плавающей точкой (то есть float) мы сталкиваемся с тем, что в результате вычислений мы получаем не совсем верный результат:


number = 0.1 + 0.1 + 0.1
print(number)       # 0.30000000000000004

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

Ключевым компонентом для работы с числами в этом модуле является класс Decimal. Для его применения нам надо создать его объект с помощью конструктора. В конструктор передается строковое значение, которое представляет число:


from decimal import Decimal

number = Decimal("0.1")

После этого объект Decimal можно использовать в арифметических операциях:


from decimal import Decimal

number = Decimal("0.1")
number = number + number + number
print(number)       # 0.3

В операциях с Decimal можно использовать целые числа:


number = Decimal("0.1")
number = number + 2

Однако нельзя смешивать в операциях дробные числа float и Decimal:


number = Decimal("0.1")
number = number + 0.1	# здесь возникнет ошибка

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


number = Decimal("0.10")
number = 3 * number
print(number)       # 0.30

Строка «0.10» определяет два знака в дробной части, даже если последние символы будут представлять ноль. Соответственно «0.100» представляет три знака в дробной части.

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

Объекты Decimal имеют метод quantize(), который позволяет округлять числа. В этот метод в качестве первого аргумента передается также объект Decimal, который указывает формат округления числа:


from decimal import Decimal

number = Decimal("0.444")
number = number.quantize(Decimal("1.00"))
print(number)       # 0.44

number = Decimal("0.555678")
print(number.quantize(Decimal("1.00")))       # 0.56

number = Decimal("0.999")
print(number.quantize(Decimal("1.00")))       # 1.00

Используемая строка «1.00» указывает, что округление будет идти до двух знаков в дробной части.

По умолчанию округление описывается константой ROUND_HALF_EVEN, при котором число округляется в большую сторону, если оно нечетное, а предыдущее перед ним больше 4. Например:


from decimal import Decimal, ROUND_HALF_EVEN


number = Decimal("10.025")
print(number.quantize(Decimal("1.00"), ROUND_HALF_EVEN))       # 10.02

number = Decimal("10.035")
print(number.quantize(Decimal("1.00"), ROUND_HALF_EVEN))       # 10.04

Стратегия округления передается в качестве второго параметра в quantize.

Строка «1.00» означает, что округление будет идти до двух чисел в дробной части. Но в первом случае «10.025» — вторым знаком идет 2 — четное число, поэтому, несмотря на то, что следующее число 5, двойка не округляется до тройки.

Во втором случае «10.035» — вторым знаком идет 3 — нечетное число, поэтому оно округляется до 4.

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

  • ROUND_HALF_UP: округляет число в сторону повышения, если после него идет число 5 или выше

  • ROUND_HALF_DOWN: округляет число в сторону повышения, если после него идет число больше 5

    
    number = Decimal("10.026")
    print(number.quantize(Decimal("1.00"), ROUND_HALF_DOWN))       # 10.03
    
    number = Decimal("10.025")
    print(number.quantize(Decimal("1.00"), ROUND_HALF_DOWN))       # 10.02
    
  • ROUND_05UP: округляет только 0 до единицы, если после него идет 5

    
    number = Decimal("10.005")
    print(number.quantize(Decimal("1.00"), ROUND_05UP))       # 10.01
    
    number = Decimal("10.025")
    print(number.quantize(Decimal("1.00"), ROUND_05UP))       # 10.02
    
  • ROUND_CEILING: округляет число в большую сторону вне зависимости от того, какое число идет после него

    
    number = Decimal("10.021")
    print(number.quantize(Decimal("1.00"), ROUND_CEILING))       # 10.03
    
    number = Decimal("10.025")
    print(number.quantize(Decimal("1.00"), ROUND_CEILING))       # 10.03
    
  • ROUND_FLOOR: не округляет число вне зависимости от того, какое число идет после него

    
    number = Decimal("10.021")
    print(number.quantize(Decimal("1.00"), ROUND_FLOOR))       # 10.02
    
    number = Decimal("10.025")
    print(number.quantize(Decimal("1.00"), ROUND_FLOOR))       # 10.02
    

PHP Round Number: округление чисел в PHP с помощью round ()

Не знаю, как вы, но мне трудно читать эти преобразованные температуры из моего последнего поста. Преобразование 400 градусов по Фаренгейту отображается как 204 градуса Цельсия, а преобразование 200 градусов по Цельсию отображается как 392 градуса по Фаренгейту. Эти числа непросто установить в духовке, и с первого взгляда сложно их усвоить. Давайте исправим эту проблему, округлив до ближайших пяти градусов с помощью функции PHP round () !

Округление до ближайшего 5 градусов

Функция PHP round () принимает десятичное число (a.к.а. число с плавающей запятой) и округляет в большую или меньшую сторону. В наиболее простой форме по умолчанию десятичная дробь округляется до ближайшего целого числа. Например, round (3.457) даст вам результат 3 .

Если вы хотите сохранить некоторые из этих десятичных знаков, вы можете добавить аргумент точности. По умолчанию 0, поэтому без значения точности round () будет просто округляться до ближайшего целого числа, как указано выше. Если вы хотите округлить предыдущий пример с точностью до 2 десятичных знаков, вы должны написать round (3.457, 2) вместо 3,46 .

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

  округление (<число, которое нужно округлить>, <точность / число десятичных знаков для округления до>)
  
Войти в полноэкранный режимВыйти из полноэкранного режима

Существует также третий аргумент, который вы можете использовать, называемый «режимом», который позволит вам контролировать способ округления. Например, хотите ли вы, чтобы округление шло в сторону нуля или от нуля либо до следующего четного или нечетного числа? Узнайте больше об этом в Руководстве по PHP.

Округление до ближайшего 5 градусов

Однако, когда дело доходит до температуры духовки, мы не просто хотим округлить до ближайшего целого числа, мы хотим округлить до ближайших 5 градусов, потому что это, скорее всего, реальная температура, на которую вы можете установить свою духовку, и читать намного легче. Но если мы просто сделаем что-то вроде round (204) , результат будет просто 204 . Как мы можем округлить это значение до ближайших 5 градусов?

Вот трюк: сначала разделите число, которое вы хотите округлить, на 5.Затем округлите его. Наконец, умножьте его еще раз на 5. Это даст вам исходное число, округленное до ближайшего кратного 5.

  $ по Цельсию = круглое (204/5) * 5;
print $ celsius;

// Это напечатает "205"
  
Войти в полноэкранный режимВыйти из полноэкранного режима

Если вместо этого вам нужно число, кратное 10, просто возьмите полученное число и разделите на 10, округлите и снова умножьте на 10.

  $ по Цельсию = круглое (204/10) * 10;
print $ celsius;

// Это напечатает "200"
  
Войти в полноэкранный режимВыйти из полноэкранного режима

Давайте посмотрим на это в действии со списком преобразования температуры из моего последнего сообщения.

Преобразование Цельсия в Фаренгейты и округление результатов

Преобразование Фаренгейта в Цельсия и округление результатов

Ну вот! Приятная температура, которую вы действительно можете ввести в свою духовку 🙂

Округление и отображение чисел в PHP

Для округления числа в PHP вы можете использовать одну из трех функций: round (), ceil () и floor (). Все эти функции принимают число в качестве входных данных и округляют значение в зависимости от используемой функции.

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

патрон (4.4); // возвращает 4

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

этаж (4.4); // возвращает 4

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

ceil (4.4); // возвращает 5

Обратите внимание, что из-за того, как числа хранятся в PHP, вы можете получить противоречивые результаты при округлении такого значения, как 4.5. Это связано с тем, как они хранятся на компьютере. Значение 4,5 может иметь фактическое значение 4,4999999999999999999999 или 4,5000000000000000000001, поэтому при попытке округлить это значение вы можете получить 4 или 5.

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

раунд (4,5 + 0,0000001); // возвращает 5

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

круглый (4.51234,2); // возвращает 4.51

Если вы хотите просто распечатать значение, а не округлить его, вы можете использовать ряд функций, которые помогут вам в этом. Самая простая функция — number_format (), которая также добавляет разделители тысяч. number_format () принимает 4 параметра, но только первый (число) является обязательным.

формат_числа (123456.1234); // возвращает 123,456

Остальные параметры:

  • десятичные дроби — количество десятичных знаков для округления значения до
  • десятичная точка — строка, которая будет использоваться в качестве десятичной точки.
  • Разделитель тысяч — Строка, которая будет использоваться в качестве разделителя тысяч.

Например:

 
  1. // выводит 123COMMA456POINT12

Немного сложнее функция money_format (), которая принимает два параметра: числовой формат и значение. На эту функцию влияет значение, установленное в категории LC_MONETARY настроек локали. Установите это значение с помощью setlocale () перед запуском функции.Дополнительные сведения о строке формата см. На веб-сайте PHP.

 
  1. $ formatString = '% i (после 17,5 %% налога)';

  2. // печатает 1234,12 фунтов стерлингов (после налога 17,5%)

Наконец, вы также можете использовать функцию sprintf () для форматирования строки и возврата вывода.

PHP: Числа с плавающей запятой — Руководство

Числа с плавающей запятой

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

$ a = 1.234;
$ b = 1,2e3;
$ c = 7E-10;
$ d = 1_234,567; // начиная с PHP 7.4.0
?>

Формально, начиная с PHP 7.4.0 (ранее подчеркивание не разрешалось):

LNUM [0-9] + (_ [0-9] +) *
DNUM ([0-9] * (_ [0-9] +) * [\.] {LNUM}) | ({LNUM} [\.] [0-9] * (_ [0-9] +) *)
EXPONENT_DNUM (({LNUM} | {DNUM}) [eE] [+ -]? {LNUM})
 

Размер поплавка зависит от платформы, но не более 1,8e308. с точностью примерно до 14 десятичных цифр является общим значением (64-битный стандарт IEEE формат).

Предупреждение

Числа с плавающей запятой имеют ограниченную точность. Хотя это зависит от системы, PHP обычно использует формат двойной точности IEEE 754, который дают максимальную относительную ошибку из-за округления в порядке 1.11e-16. Неэлементарные арифметические операции могут давать большие ошибки и, конечно же, распространение ошибок необходимо учитывать, когда выполняются несколько операций. смешанный.

Кроме того, рациональные числа, которые точно могут быть представлены как плавающие числа точек в базе 10, например 0.1 или 0,7 , не имеют точного представления как плавающие числа точек в базе 2, которая используется внутри компании, независимо от размера мантисса. Следовательно, они не могут быть преобразованы во внутренние двоичные файлы. аналоги без небольшой потери точности. Это может привести к путанице результаты: например, этаж ((0,1 + 0,7) * 10) обычно вернуть 7 вместо ожидаемого 8 , так как внутреннее представление будет чем-то вроде 7.9999999999999991118 ... .

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

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

Сравнение поплавков

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

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

$ a и $ b равны 5 цифрам точность.

$ a = 1.23456789;
$ b = 1,23456780;
$ эпсилон = 0,00001;

if (

abs ($ a- $ b) <$ epsilon) {
echo "true";
}
?>

NaN

Некоторые числовые операции могут привести к значению, представленному константой НАН . Этот результат представляет собой неопределенное или непредставимое значение в вычислениях с плавающей запятой. Любой свободный или строгий сравнение этого значения с любым другим значением, включая его самого, но кроме ИСТИНА , будет имеют результат ЛОЖЬ .

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

Функция Python round () с ПРИМЕРАМИ

Round ()

Round () — это встроенная функция, доступная в python. Он вернет вам число с плавающей запятой, которое будет округлено до десятичных знаков, указанных в качестве входных данных.

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

В этом руководстве по Python вы узнаете:

Синтаксис:

раунд (число_площадок, число_децималей)
 
Параметры
  • float_num: число с плавающей запятой, которое нужно округлить.
  • num_of_decimals: (необязательно) Количество десятичных знаков, учитываемых при округлении. Это необязательно, и если не указано, по умолчанию используется значение 0, а округление выполняется до ближайшего целого числа.
Описание

Метод round () принимает два аргумента:

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

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

Если присутствуют десятичные разряды, то есть второй аргумент, он будет округлен до заданного количества разрядов. Тип возврата будет float.

Если число после десятичного разряда задано

  • > = 5, чем +1, будет добавлено к окончательному значению
  • <5, то окончательное значение вернется в том виде, в каком оно находится до упомянутых десятичных знаков.
Возвращаемое значение

Он вернет целочисленное значение, если num_of_decimals не задано, и значение с плавающей запятой, если задано num_of_decimals. Обратите внимание, что значение будет округлено до +1, если значение после десятичной точки> = 5, в противном случае будет возвращено значение с точностью до упомянутых десятичных знаков.

Какое влияние может иметь округление? (Округление против усечения)

Лучший пример, показывающий влияние округления, — это фондовый рынок. В прошлом я.е в 1982 году Ванкуверская фондовая биржа (VSE): использовалась для усечения стоимости акций до трех знаков после запятой в каждой сделке.

Это делалось почти 3000 раз каждый день. Накопленные усечения приводят к потере около 25 баллов в месяц.

Пример усечения значений по сравнению с округлением показан ниже.

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

1000000 секунд между 0.01 и 0,05.

Примеры:
arr = [random.uniform (0,01, 0,05) для _ в диапазоне (1000000)]
 

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

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

Для того же набора чисел я использовал метод round () до 3 десятичных знаков и вычислял сумму и разницу между исходным значением и округленным значением.

Вот пример и результат

Пример 1

случайный импорт

def truncate (число):
    return int (число * 1000) / 1000

arr = [random.uniform (0,01, 0,05) для _ в диапазоне (1000000)]
sum_num = 0
sum_truncate = 0
для я в обр:
    sum_num = sum_num + я
    sum_truncate = усечь (sum_truncate + i)
    
print ("Тестирование с использованием усечения до трех знаков после запятой")
print ("Исходная сумма =", sum_num)
print ("Итого с использованием truncate =", sum_truncate)
print ("Отличие от оригинала - truncate =", sum_num - sum_truncate)

печать ("\ п \ п")
print ("Тестирование с использованием round () до 3-х знаков после запятой")
sum_num1 = 0
sum_truncate1 = 0
для я в обр:
    sum_num1 = sum_num1 + i
    sum_truncate1 = раунд (sum_truncate1 + i, 3)


print ("Исходная сумма =", sum_num1)
print ("Итого с использованием round =", sum_truncate1)
print ("Отличие от оригинала - round =", sum_num1 - sum_truncate1)
 

Вывод:

Тестирование с использованием усечения до 3 знаков после запятой
Исходная сумма = 29985.958619386867
Итого с использованием truncate = 29486.057
Отличие от оригинала - truncate = 499.

93868665 Тестирование с использованием round () до 3 знаков после запятой Исходная сумма = 29985,958619386867 Итого с использованием раунда = 29985.912 Отличие от оригинала - круглое = 0,04661938686695066

Разница между исходным и последующим усечением составляет 499,

93868665, а от округления — 0,04661938686695066

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

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

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

# тестирование раунд ()

float_num1 = 10.60 # здесь значение будет округлено до 11, так как после десятичной запятой число 6, то есть> 5

float_num2 = 10.40 # здесь значение будет округлено до 10, так как после десятичной запятой число 4, то есть <= 5

float_num3 = 10.3456 # здесь значение будет 10,35, так как после двух десятичных знаков значение> = 5

float_num4 = 10.3445 # здесь значение будет 10,34, т.к. после двух десятичных знаков значение <5

print ("Округленное значение без num_of_decimals:", round (float_num1))
print ("Округленное значение без num_of_decimals:", round (float_num2))
print ("Округленное значение с num_of_decimals как 2 равно:", round (float_num3, 2))
print ("Округленное значение с num_of_decimals как 2 равно:", round (float_num4, 2))
 

Выход:

Округленное значение без num_of_decimals: 11
Округленное значение без num_of_decimals: 10
Округленное значение с num_of_decimals как 2 составляет: 10.35 год
Округленное значение с num_of_decimals как 2 составляет: 10,34
 

Пример: округление целых значений

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

# тестирование round () на целое число

число = 15

print («Результат», round (num))
 

Выход:

Выход 15
 

Пример: округление отрицательных чисел

Давайте посмотрим несколько примеров того, как округление работает с отрицательными числами

# тестирование раунд ()

число = -2.8
число1 = -1,5
print ("Значение после округления", round (num))
print ("Значение после округления", round (num1))
 

Выход:

C: \ pythontest> Python testround.py
Значение после округления -3.
Значение после округления -2.
 

Пример: Round Numpy Arrays

Как округлить numpy-массивы в Python?

Чтобы решить эту проблему, мы можем использовать модуль numpy и использовать метод numpy.round () или numpy.around (), как показано в примере ниже.

Использование numpy.round ()

# тестирование раунд ()
импортировать numpy как np

arr = [-0,341111, 1,455098989, 4,232323, -0,3432326, 7,626632, 5,122323]

arr1 = np.round (обр, 2)

печать (arr1)
 

Выход:

C: \ pythontest> Python testround.py
[-0,34 1,46 4,23 -0,34 7,63 5,12]
 

Мы также можем использовать numpy.around (), который дает тот же результат, что и в примере ниже.

Пример: десятичный модуль

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

Модуль Decimal имеет типы округления, как показано ниже:

  • ROUND_CEILING: округляется до бесконечности,
  • ROUND_DOWN: округляется до нуля,
  • ROUND_FLOOR: округляется до -Infinity,
  • ROUND_HALF_DOWN: округляется до ближайшего значения, идущего к нулю,
  • ROUND_HALF_EVEN: округляется до ближайшего значения, идущего до ближайшего четного целого числа,
  • ROUND_HALF_UP: округляется до ближайшего значения, уходящего от нуля
  • ROUND_UP: оно будет раунд, где значение уйдет от нуля.

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

Пример:

Использование методов round () и десятичной дроби

импорт десятичной дроби
round_num = 15.456

final_val = раунд (round_num; 2)

# Использование десятичного модуля
final_val1 = десятичное.Десятичное (round_num) .quantize (десятичное.Десятичное ('0,00'), округление = десятичное.ROUND_CEILING)
final_val2 = десятичный.Десятичное (round_num) .quantize (decimal.Decimal ('0.00'), округление = decimal.ROUND_DOWN)
final_val3 = десятичное.Десятичное (round_num) .quantize (десятичное.Десятичное ('0,00'), округление = десятичное.ROUND_FLOOR)
final_val4 = десятичное.Десятичное (round_num) .quantize (decimal.Decimal ('0,00'), округление = десятичное.ROUND_HALF_DOWN)
final_val5 = десятичное.Десятичное (round_num) .quantize (десятичное.Десятичное ('0,00'), округление = десятичное.ROUND_HALF_EVEN)
final_val6 = десятичное.Десятичное (round_num) .quantize (десятичное.Десятичное ('0,00'), округление = десятичное.ROUND_HALF_UP)
final_val7 = десятичное.Десятичное (round_num) .quantize (десятичное.Десятичное ('0,00'), округление = десятичное.ROUND_UP)

print ("Использование round ()", final_val)
print ("Использование десятичного числа - ROUND_CEILING", final_val1)
print ("Использование десятичного числа - ROUND_DOWN", final_val2)
print ("Использование десятичного числа - ROUND_FLOOR", final_val3)
print ("Использование десятичного числа - ROUND_HALF_DOWN", final_val4)
print ("Использование десятичного числа - ROUND_HALF_EVEN", final_val5)
print ("Использование десятичного числа - ROUND_HALF_UP", final_val6)
print ("Использование десятичного числа - ROUND_UP", final_val7)
 

Выход:

Использование round () 15.46
Использование десятичного числа - ROUND_CEILING 15.46
Использование десятичного числа - ROUND_DOWN 15.45
Использование десятичного числа - ROUND_FLOOR 15.45
Использование десятичного числа - ROUND_HALF_DOWN 15.46
Использование десятичного числа - ROUND_HALF_EVEN 15.46
Использование десятичной дроби - ROUND_HALF_UP 15.46
Использование десятичного числа - ROUND_UP 15.46
 

Сводка:

  • Round (float_num, Num_of_decimals) - встроенная функция, доступная в Python. Он вернет вам число с плавающей запятой, которое будет округлено до десятичных знаков, указанных в качестве входных данных.
  • float_num: число с плавающей запятой, которое нужно округлить.
  • Num_of_decimals: Это количество десятичных знаков, учитываемых при округлении.
  • Возвращает целочисленное значение, если num_of_decimals не задано, и значение с плавающей запятой, если задано num_of_decimals.

Cut-N-Paste Corner: функция PHP - динамическое округление до ближайших 10, 100, 1000 или любого другого значения (секс-игрушка с графической осью)

Один из отдела «Случайное извлечение дерьма из ящика для мусора»... пока я сижу здесь и смотрю, как мой любимый Red Sox цементирует свой путь ВЫХОДА из плей-офф ... {вздох}

Вот небольшая функция, которую я использую при построении красивых маленьких графиков в моих PHP Reporting / Web Interfaces. Полезно рассчитать максимальное значение для оси графика. Поскольку мы никогда не знаем, какими будут значения, пока мы не вытащим эти данные из БД - это может быть 10, может быть 10 000 или 10 000 000 (иногда даже «яблоко», но плод в целое число преобразования будут другой день)

// $ biggs будет самым большим числом в вашем наборе
// (при условии "максимального" значения построения графика
function RoundUptoNearestN ($ biggs) {

$ rounders = (strlen ($ biggs) - 2) * -1;
$ places = strlen ($ biggs) -2;

$ counter = 0;
while ($ counter <= $ places) {
$ counter ++;
if ($ counter == 1) {
$ держатель = $ держатель.'1'; }
else {
$ Holder = $ holder.'0 '; }
}

$ biggs = $ biggs + $ holder;
$ biggs = round ($ biggs, $ rounders);

if ($ biggs <100) {
if ($ biggs <100) {$ biggs = 100; }
else {$ biggs = 100; }
}
return $ biggs;
}

// Использование:
echo '

'; 
echo RoundUptoNearestN (1424)."\ п"; // возвращает 1500
echo RoundUptoNearestN (123). "\ n"; // возвращает 130
echo RoundUptoNearestN (154368). "\ n"; // возвращает 160000
echo RoundUptoNearestN (12334). "\ n"; // возвращает 13000
echo RoundUptoNearestN (75). "\ n"; // возвращает 100
echo '
';
/// и т. Д. И т. Д .: P

?>

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

Если вас интересует упомянутая мною «сексуальная маленькая диаграмма» - посмотрите Open Flash Chart, ее быструю, красивую и простую работу.

Если кто-то хочет поправить меня версией ONE LINE, чтобы смутить меня - дерзайте! Но помните:

  1. Это не значит, что я ошибаюсь
  2. Это не прибавит дюймов к твоему члену
  3. Эти слухи о Mountain Dew могут быть правдой
  4. ВСЕМ видят твою лысину - хватит лгать!

Обращаюсь! Я осталась! 🙂

LessThanDot - методы округления SQL Server

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

Важно отметить, что в большинстве случаев функция Round дает желаемый результат. Предполагаемая цель кода, показанного ниже, - воздействовать только на те случаи, когда число может быть округлено в большую или меньшую сторону, поскольку округленное значение находится точно посередине между округленным числом в большую и меньшую сторону.Например, когда вы округляете 3,5 до ближайшего целого числа, каков должен быть результат? 3 или 4? Когда вы выполняете много вычислений с округленными числами, стохастический раунд или раунд банкиров будет более точным, чем любой другой метод, потому что (статистически) крайние случаи будут компенсировать друг друга, что приведет к более точному результату.

Интересно отметить, что многие клиентские языки, такие как vb6 и .NET Framework, реализуют банковское округление. Начиная с .net framework 2.0 есть необязательный третий аргумент функции round, который позволяет вам изменять поведение. В любом случае это отличается от реализации округления в SQL Server, которая всегда «округляет от нуля». Например, round (4,25, 1) = 4,3 и Round (-4,25, 1) = -4,3. Оба числа округлены от нуля. В VB Round (4,25, 1) = 4,2

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

 Value Up Down к нулю вдали от нулевого банкирского стохастика
-------- ---- ---- ------------ -------------- ------- - ---------
 4.15 4,2 4,1 4,1 4,2 4,2 4,1 или 4,2
 4,1 5001 4,2 4,2 4,2 4,2 4,2 4,2
 4,25 4,3 4,2 4,2 4,3 4,2 4,2 или 4,3
-4,15 -4,1 -4,2 -4,1 -4,2 -4,2 -4,1 или -4,2
-4,25 -4,2 -4,3 -4,2 -4,3 -4,2 -4,2 или -4,3
-4,25001 -4,3 -4,3 -4,3 -4,3 -4,3 -4,3
 

Округлить:

Этот метод всегда округляет число до ближайшего большего числа.Например, при округлении 3,1 в большую сторону получается 4, а при округлении -3,1 в большую сторону получается -3. В SQL Server самый простой способ достичь «RoundUp» - использовать функцию потолка. К сожалению, функция потолка работает только с целыми числами. В RoundsUp нет встроенной функции, в которой можно было бы указать количество цифр. Это не проблема, мы можем просто построить свои собственные.

  Создать функцию dbo.RoundUp (@Val Decimal (32,16), @Digits Int)
Возвращает десятичное число (32,16).
В КАЧЕСТВЕ
Начинать
    Вернуть регистр, когда Abs (@Val - Round (@Val, @Digits, 1)) * Power (10, @ Digits + 1) = 5
                Затем потолок (@Val * Power (10, @ Digits)) / Power (10, @Digits)
                Другой раунд (@Val, @Digits)
                Конец
Конец
  

Округлить вниз:

Этот метод аналогичен округлению в большую сторону, за исключением того, что он округляется до ближайшего меньшего числа.Например, округление 3,1 в меньшую сторону составляет 3, округление -3,1 в меньшую сторону составляет -4. В SQL Server есть функция пола, которая округляет в большую сторону. Как и функция потолка, функция пола не поддерживает количество цифр (работает только с целыми числами). Еще одна функция на помощь.

  Создать функцию dbo.RoundDown (@Val Decimal (32,16), @Digits Int)
Возвращает десятичное число (32,16).
В КАЧЕСТВЕ
Начинать
    Вернуть регистр, когда Abs (@Val - Round (@Val, @Digits, 1)) * Power (10, @ Digits + 1) = 5
                Затем пол (@Val * Power (10, @ Digits)) / Power (10, @Digits)
                Другой раунд (@Val, @Digits)
                Конец
Конец
  

Округление от нуля:

Этот метод делает именно это.3,5 округления от нуля до 4. -3,5 округления от нуля до -4. Реализация Round Away From Zero - самая простая для использования в SQL Server. Функция ОКРУГЛ. Уже делает это, и она также вмещает различное количество цифр.

Раунд к нулю:

В этом методе 3,5 округляет до 3, а -3,5 округляет до -3. Реализация Round Towards Zero также относительно проста в SQL Server. У функции Round есть необязательный третий параметр, который просто усекает число до количества десятичных знаков.К сожалению, это не проверяет крайний случай, когда последняя цифра равна 5, за которой идут нули.

4,15 следует округлить до 4,1

4,15000001 следует округлить до 4,2

Использование 3-го аргумента функции round будет слепо усекать конечные числа, поэтому оба будут округлены до 4,1. Это не то, что нам нужно, поэтому нам нужно написать другую функцию.

  Создать функцию dbo.RoundToZero (@Val Decimal (32,16), @Digits Int)
Возвращает десятичное число (32,16).
В КАЧЕСТВЕ
Начинать
    Вернуть регистр, когда Abs (@Val - Round (@Val, @Digits, 1)) * Power (10, @ Digits + 1) = 5
                Затем раунд (@Val, @Digits, 1)
                Другой раунд (@Val, @Digits)
                Конец
Конец
  

Круглый к четному:

Это известно под множеством разных названий (округление Банкиров, округление без смещения, округление по Гауссу и округление статистиков).При использовании этого метода делаются особые исключения, если последняя удаляемая цифра равна 5. Если это так, число округляется до следующего четного числа.

Пример,

4,15 Банкиры Округление до 1 цифр - 4,2

4,25 Банкиры Округление до 1 цифр - 4,2

Это происходит потому, что все справа от числа цифр (5) равно 5. Если бы это было 51, число было бы округлено в большую сторону. Меньше 50, число округляется в меньшую сторону. Так как это ровно 50, нам нужно проверить цифру слева от нее (1-й десятичный разряд).Если это четное число, округленное значение усекается. Если это нечетное число (например, 1 в 4.15), оно округляется до следующего четного числа (до 4.2).

Мы можем написать другую функцию в SQL Server для реализации банковского округления.

  Создать функцию dbo.BankersRound (@Val Decimal (32,16), @Digits Int)
Возвращает десятичное число (32,16).
В КАЧЕСТВЕ
Начинать
    Вернуть регистр, когда Abs (@Val - Round (@Val, @Digits, 1)) * Power (10, @ Digits + 1) = 5
                Затем Round (@Val, @Digits, Case When Convert (int, Round (abs (@Val) * power (10, @ Digits), 0, 1))% 2 = 1 Then 0 Else 1 End)
                Другой раунд (@Val, @Digits)
                Конец
Конец
  

Стохастическое округление

Это похоже на «Округлить до четного».Когда оставшиеся цифры - это 5, за которыми следуют нули, мы произвольно округляем в меньшую или большую сторону. Реализовать это немного сложнее, потому что SQL Server не любит случайные числа в пользовательских функциях. Чтобы обойти это ограничение, мы можем создать представление, которое возвращает случайное число, и вызывать это представление из функции. Во-первых, вид:

  Создать вид vw_RandomBit
В качестве
Выберите регистр при преобразовании (Char (1), Convert (VarChar (36), NewId ()))> '7'
            Тогда 1
            Остальное 0
            Конец как RandomBit
  

Затем мы можем создать эту функцию.

  Создать функцию dbo.StochasticRound (@Val Decimal (32,16), @Digits Int)
Возвращает десятичное число (32,16).
В КАЧЕСТВЕ
Начинать
    Вернуть регистр, когда Abs (@Val - Round (@Val, @Digits, 1)) * Power (10, @ Digits + 1) = 5
                Затем Round (@Val, @Digits, Convert (int, (Select RandomBit From vw_RandomBit)))
                Другой раунд (@Val, @Digits)
                Конец
Конец
  

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

Получение 100% с округлением процентов | автор: João Ferreira

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

Давайте использовать проценты при отображении оценок. Процент должен быть относительно общего балла.

Хорошо, это кажется достаточно простым, поэтому давайте вычислим эти проценты:

 18.562874251497007% 
20.958083832335326%
18.562874251497007%
19.161676646706585%
22.75449101796407%

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

Хорошо, подойдет простое округление:

 19% 
21%
19%
19%
23%

Но подождите ... это не дает в сумме 100%! Фактически это составляет 101%! Что ж, проблема слепого округления. Итак, как мы можем гарантировать, что результат в процентах всегда будет составлять 100%?

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

, который указал мне на алгоритм метода наибольшего остатка. Это очень простой алгоритм, который состоит из:

  1. Округление всех значений до ближайшего целого числа;
  2. Определение разницы между суммой округленных значений и общим значением;
  3. Распределение разницы между округленными значениями в порядке убывания их десятичных частей.

Учитывая исходный набор данных:

Начнем с округления всех значений в меньшую сторону:

 => [18, 20, 18, 19, 22] 

Теперь разница между суммой округленных значений и общим значением (в в данном случае 100%):

 => 3 

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

 => [20.
        
	
Posted in Php

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *

Theme: Overlay by Kaira Extra Text
Cape Town, South Africa