Как сделать чтобы access не округлял?

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

Зачем округлять числа?

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

0.1 * 0.2;
> 0.020000000000000004

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

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

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

Как сделать чтобы access не округлял?

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

Узнать подробнее

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

Округление десятичных чисел

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

Если в toFixed() не задан аргумент, то по умолчанию выставляется 0, т.е. без знаков после запятой, максимальное значение 20.

Если в toPrecision не задан аргумент, число не меняется.

var randNum = 6.25;
randNum.toFixed();
> «6»

Math.PI.toPrecision(1);
> «3»

var randNum = 87.335;
randNum.toFixed(2);
> «87.33»

var randNum = 87.337;
randNum.toPrecision(3);
> «87.3»

Важное замечание

Оба метода toFixed() и toPrecision() возвращают округленное представление строки результата, а не число. Т.е. при «сложении» переменных rounded и randNum будет произведена конкатенация, а не сложение:

console.log(randNum + rounded);
> «6.256»

console.log(randNum + rounded);

Если нужно привести результат к числу, воспользуйтесь parseFloat:

var randNum = 6.25;
var rounded = parseFloat(randNum.toFixed(1));
console.log(rounded);
> 6.3

var rounded = parseFloat(randNum.toFixed(1));

(обратите, что число 5 округлилось в большую сторону, за исключением редких случаев; более подробно чуть ниже.) Также методы toFixed() и toPrecision() бывают полезны, когда необходимо целому числу приписать десятичную часть. Это особенно удобно при работе с валютами:

var wholeNum = 1
var dollarsCents = wholeNum.toFixed(2);
console.log(dollarsCents);
> «1.00»

var dollarsCents = wholeNum.toFixed(2);console.log(dollarsCents);

Обратите внимание, что если в числе больше цифр, чем в аргументе toPrecision, то оно будет записано в научном виде (с мантиссой и порядком):

var num = 123.435
num.toPrecision(2);
> «1.2e+2»

Как избегать ошибок при округлении десятичных чисел

В некоторых случаях toFixed и toPrecision округляют 5 не вверх, а вниз:

var numTest = 1.005;
numTest.toFixed(2);
> 1;

Результат выше должен быть 1.01, а не 1. Если для вас важна точность, я бы порекомендовал вам решение от Jack L Moore, который в вычислениях использует экспоненциальные числа:

function round(value, decimals) {
return Number(Math.round(value+'e'+decimals)+'e-'+decimals);
}

function round(value, decimals) { return Number(Math.round(value+'e'+decimals)+'e-'+decimals);

И результат:

На MDN есть еще более надежное решение.

Усечение десятичных чисел

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

function truncated(num) {
return Math.trunc(num * 100) / 100;
}

truncated(3.1416)
> 3.14

function truncated(num) { return Math.trunc(num * 100) / 100;

Если хотите добавить немного гибкости, можно воспользоваться побитовым оператором ~~:

function truncated(num, decimalPlaces) {
var numPowerConverter = Math.pow(10, decimalPlaces);
return ~~(num * numPowerConverter)/numPowerConverter;
}

function truncated(num, decimalPlaces) { var numPowerConverter = Math.pow(10, decimalPlaces); return ~~(num * numPowerConverter)/numPowerConverter;

Результат:

var randInt = 35.874993;
truncated(randInt,3);
> 35.874

В следующей статье я поподробнее расскажу про побитовые операции.

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

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

Math.round(4.3)
> 4

Math.round(4.5)
> 5 Как сделать чтобы access не округлял?

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

Узнать подробнее

Обратите внимание, что «половинные значения» типа .5 округляются вверх.

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

Если вам необходимо округлить число вниз, воспользуйтесь Math.floor:

Math.floor(42.23);
> 42

Math.floor(36.93);
> 36

Обратите внимание, что в данном случае округляются вниз все числа, даже отрицательные. Представьте себе небоскреб с бесконечным количеством этажей вверх и вниз (нижние этажи это отрицательные числа). Если вы в лифте находитесь между минус вторым и минус третьим этажами (значение -2.5), метод Math.floor доставит вам на -3 этаж:

Если вы не хотите, чтобы отрицательные числа тоже округлялись в меньшую сторону, воспользуйтесь Math.trunc. Данный метод поддерживается во всех современных браузерах )кроме IE/Edge):

Math.trunc(-41.43);
> -41

На MDN также есть трехстрочный полифил, который добавляют Math.trunc поддержку старых браузеров и IE/Edge.

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

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

Math.ceil(42.23);
> 43

Math.ceil(36.93);
> 37

Округление вверх и вниз до ближайшего кратного числа

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

function roundTo5(num) {
return Math.round(num/5)*5;
}

return Math.round(num/5)*5;

Результат:

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

function roundToMultiple(num, multiple) {
return Math.round(num/multiple)*multiple;
}

function roundToMultiple(num, multiple) { return Math.round(num/multiple)*multiple;

Чтобы вызвать функцию, необходимо указать два параметра, само число и кратность:

var initialNumber = 11;
var multiple = 10;
roundToMultiple(initialNumber, multiple);
> 10;

roundToMultiple(initialNumber, multiple);

Чтобы округлять вниз или вверх ставьте в функции ceil или floor.

Установка диапазона для числа

Бывает множество случаев, когда мы получаем число Х, и нам необходимо загнать его в определенный диапазон. К примеру, нам нужно число от 1 до 100, а получили мы 123. Тут нам пригодятся методы min (всегда возвращает наименьшее из набора чисел) и max (наибольшее число из набора). Пример с диапазоном от 1 до 100:

var lowBound = 1;
var highBound = 100;
var numInput = 123;
var clamped = Math.max(lowBound, Math.min(numInput, highBound));
console.log(clamped);
> 100;

var clamped = Math.max(lowBound, Math.min(numInput, highBound));

Это можно превратить в функцию или расширение класса Number, вариант с расширением впервые предложил Daniel X. Moore:

Number.prototype.clamp = function(min, max) {
return Math.min(Math.max(this, min), max);
};

Number.prototype.clamp = function(min, max) { return Math.min(Math.max(this, min), max);

Результат:

(numInput).clamp(lowBound, highBound);

Округление по Гауссу

Округление по Гауссу, которое также называют округлением для «банкиров», конвергентным округлением, голландским округлением и нечетным-четным округлением, это метод округления без статистического смещения; в обычном округлении числа автоматически завышаются. В округлении по Гауссу число приводится к ближайшему четному. Лучшее известное мне решение у Tim Down:

function gaussRound(num, decimalPlaces) {
var d = decimalPlaces || 0,
m = Math.pow(10, d),
n = +(d ? num * m : num).toFixed(8),
i = Math.floor(n), f = n — i,
e = 1e-8,
r = (f > 0.5 — e && f < 0.5 + e) ? ((i % 2 == 0) ? i : i + 1) : Math.round(n); return d ? r / m : r; }

function gaussRound(num, decimalPlaces) { var d = decimalPlaces || 0, n = +(d ? num * m : num).toFixed(8), i = Math.floor(n), f = n — i, r = (f > 0.5 — e && f 2

gaussRound(3.5)
> 4

gaussRound(2.57,1)
> 2.6

Десятичные числа в CSS

JavaScript часто используют для вычисления позиции или значения трансформации HTML элементов. У вас может возникнуть вопрос, а что будет, если задать десятичное значение элементу: #box { width: 63.667731993px; }

#box { width: 63.667731993px; }

Плюс для нас в том, что современные браузеры понимают десятичные значения, присвоенные к блоковым элементам, в том числе проценты и пиксели.
Источник: http://thenewcode.com/
Редакция: Команда webformyself.

Как сделать чтобы access не округлял?

JavaScript. Быстрый старт

Изучите основы JavaScript на практическом примере по созданию веб-приложения

Узнать подробнее

Источник: https://webformyself.com/okruglenie-chisel-v-javascript/

VBA Excel. Округление чисел (особенности)

Округление чисел в VBA Excel с помощью оператора Round и встроенной функции рабочего листа WorksheetFunction.Round. Особенности бухгалтерского и обычного округления.

Оператор Round
Оператор WorksheetFunction.Round

Оператор Round

А вы знаете, что при использовании для округления чисел в VBA Excel оператора Round, вы можете получить совершенно не тот результат, который ожидали? И ведь это действительно так!

Скопируйте в модуль VBA следующую процедуру и запустите ее выполнение:

Sub Test_1()
Dim a1 As Single, a2 As Single, a3 As Single, a4 As Single
a1 = Round(1.5, 0)
a2 = Round(2.5, 0)
a3 = Round(3.5, 0)
a4 = Round(4.5, 0)
MsgBox «Round(1.5, 0)=» & a1 & vbNewLine & _
«Round(2.5, 0)=» & a2 & vbNewLine & _
«Round(3.5, 0)=» & a3 & vbNewLine & _
«Round(4.5, 0)=» & a4
End Sub

В результате вы получите это:

Как сделать чтобы access не округлял?
Удивительно, не правда ли? Как же так получилось?

Дело в том, что оператор Round осуществляет «бухгалтерское» (или «банковское») округление, которое призвано при большом количестве таких операций свести погрешность к минимуму.

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

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

Еще можно сформулировать «бухгалтерское» округление так: при отбрасывании пятерки число округляется к ближайшему четному. Обратите внимание, что в результатах нашего примера все полученные числа — четные.
Проверим погрешность:

Сумма исходных чисел: 1.5 + 2.5 + 3.5 +4.5 = 12
Сумма округленных чисел: 2 + 2 + 4 + 4 = 12

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

Оператор WorksheetFunction.Round

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

Скопируйте в модуль VBA процедуру с использованием WorksheetFunction.Round и запустите ее выполнение:

Sub Test_2()
Dim a1 As Single, a2 As Single, a3 As Single, a4 As Single
a1 = WorksheetFunction.Round(1.5, 0)
a2 = WorksheetFunction.Round(2.5, 0)
a3 = WorksheetFunction.Round(3.5, 0)
a4 = WorksheetFunction.Round(4.5, 0)
MsgBox «WorksheetFunction.Round(1.5, 0)=» & a1 & vbNewLine & _
«WorksheetFunction.Round(2.5, 0)=» & a2 & vbNewLine & _
«WorksheetFunction.Round(3.5, 0)=» & a3 & vbNewLine & _
«WorksheetFunction.Round(4.5, 0)=» & a4
End Sub

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

Сумма исходных чисел: 1.5 + 2.5 + 3.5 +4.5 = 12
Сумма округленных чисел: 2 + 3 + 4 + 5 = 14

Результат очевиден — в данном случае сумма округленных чисел на 2 единицы больше суммы исходных.

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

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

Источник: https://vremya-ne-zhdet.ru/vba-excel/okrugleniye-chisel-round/

MS Access: Round Function

Как сделать чтобы access не округлял?

This MSAccess tutorial explains how to use the Access Round function with syntax and examples.

Description

The Microsoft Access Round function returns a number rounded to a specified number of decimal places. However, the Round function behaves a little peculiar and uses something commonly referred to as bankers rounding. So before using this function, please read the following:

The Round function utilizes round-to-even logic. If the expression that you are rounding ends with a 5, the Round function will round the expression so that the last digit is an even number.

For example:

Round (12.55, 1)
Result: 12.6 (rounds up) Round (12.65, 1)
Result: 12.6 (rounds down) Round (12.75, 1)
Result: 12.8 (rounds up)

In these cases, the last digit after rounding is always an even number. So, be sure to only use the Round function if this is your desired result.

Syntax

The syntax for the Round function in MS Access is:

Round ( expression, [ decimal_places ] )

Parameters or Arguments

expression A numeric expression that is to be rounded. decimal_places Optional. It is the number of decimal places to round the expression to. If this parameter is omitted, then the Round function will return an integer.

Applies To

The Round function can be used in the following versions of Microsoft Access:

Access 2016, Access 2013, Access 2010, Access 2007, Access 2003, Access XP, Access 2000

Example

Let's look at how to use the Round function in MS Access:

Round (210.67, 1)
Result: 210.7 Round (210.67, 0)
Result: 211 Round (210.67)
Result: 211

Example in VBA Code

The Round function can be used in VBA code in Microsoft Access.

For example:

Dim LNumber As Double

LNumber = Round (210.67, 1)

In this example, the variable called LNumber would now contain the value of 210.7.

Example in SQL/Queries

You can also use the Round function in a query in Microsoft Access.

For example:

Как сделать чтобы access не округлял?

In this query, we have used the Round function as follows:

Expr1: Round([UnitPrice],1)

This query will return the UnitPrice rounded to 1 decimal place and display the results in a column called Expr1. You can replace Expr1 with a column name that is more meaningful.

For example:

RoundedValue: Round([UnitPrice],1)

The results would now be displayed in a column called RoundedValue.

Tip to Avoid Bankers Rounding:

If you want to avoid bankers rounding, you can create your own custom function as follows:

' This function overcomes the bankers Rounding that occurs in the
' built-in VBA Round function to provide true (symmetric) numeric Rounding
' Created by TechOnTheNet.com
Public Function StandardRound(pValue As Double, pDecimalPlaces As Integer) As Variant

Dim LValue As String
Dim LPos As Integer
Dim LNumDecimals As Long
Dim LDecimalSymbol As String
Dim QValue As Double

' Return an error if the decimal places provided is negative
If pDecimalPlaces < 0 Then StandardRound = CVErr(2001) Exit Function End If ' If your country uses a different symbol than the "." to denote a decimal ' then change the following LDecimalSymbol variable to that character LDecimalSymbol = "." ' Determine the number of decimal places in the value provided using ' the length of the value and the position of the decimal symbol LValue = CStr(pValue) LPos = InStr(LValue, LDecimalSymbol) LNumDecimals = Len(LValue) - LPos ' Round if the value provided has decimals and the number of decimals ' is greater than the number of decimal places we are rounding to If (LPos > 0) And (LNumDecimals > 0) And (LNumDecimals > pDecimalPlaces) Then

' Calculate the factor to add
QValue = (1 / (10 ^ (LNumDecimals + 1)))

' Symmetric rounding is commonly desired so if the value is
' negative, make the factor negative
' (Remove the following 3 lines if you require «Round Up» rounding)
If (pValue < 0) Then QValue = -QValue End If ' Add a 1 to the end of the value (For example, if pValue is 12.65 ' then we will use 12.651 when rounding) StandardRound = Round(pValue + QValue, pDecimalPlaces) ' Otherwise return the original value Else StandardRound = pValue End If End Function

And then call the StandardRound function instead of using the Round function.

Frequently Asked Questions

Question: I read your explanation of the Round function using the round-to-even logic. However, I really need to round some values in the traditional sense (where 5 always rounds up). How can I do this?

Answer: You could always use the following logic:

If you wanted to round 12.65 to 1 decimal place in the traditional sense (where 12.65 rounded to 1 decimal place is 12.7, instead of 12.6), try adding 0.000001 to your number before applying the Round function:

Round(12.45+0.000001,1)

By adding the 0.000001, the expression that you are rounding will end in 1, instead of 5…causing the Round function to round in the traditional way.

And the 0.000001 does not significantly affect the value of your expression so you shouldn't introduce any calculation errors.

Источник: https://www.techonthenet.com/access/functions/numeric/round.php

Округление в Аксессе

Автор Allen Browne, декабрь 2007. Обновлено: август 2008.

Оригинал Rounding in Access

Перевел с английского Александр Артамонов

Для округления чисел в Access 2000 и более поздних версих есть встроенная функция Round(). Для более ранних версий используйте вот эту пользовательскую функцию округления Кена Гетца.

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

Используйте функцию Round() в источнике данных текстового поля или в вычисляемом поле запроса.
Скажем, у вас есть такое выражение в строке «Поле» в конструкторе запросов: Налог: [Стоимость] * [СтавкаНалога] Чтобы округлить до ближайшей копейки, используйте:
Налог: Round([Стоимость] * [СтавкаНалога], 2)

Округление вниз

Чтобы округлить все дробные цифры до ближайшего целого вниз, используйте Int(): Int([МоеПоле])
Все эти числа будут округлены вниз до 2: 2,1, 2,5, 2,8, and 2,99.
Чтобы округлить вниз до ближайшей копейки (напр.

10,2199 руб становятся 10,21 руб), умножьте на 100, округлите, и затем разделите на 100: Int(100 * [МоеПоле]) / 100

Заметьте, что получается при округлении вниз отрицательных величин: Int(-2.1) дает -3, так как это и есть целое число снизу.

Чтобы округлять по направлению к нулю, используйте Fix() вместо Int(): Fix(100 * [МоеПоле]) / 100

Округление вверх

Чтобы округлить вверх к ближайшему большему целому, воспользуйтесь способом, которым Int() округляет отрицательные числа: — Int( — [МоеПоле])

Как показано выше, Int(-2.1) округляет вниз до -3. Поэтому такое выражение округляет 2,1 до to 3.

Чтобы округлить вверх до ближайшей копейки, умножьте на -100, округлите, и разделите на -100: Int(-100 * [МоеПоле]) / -100

Округлить до ближайших 5 копеек

Чтобы округлить до ближайших 5 копеек, умножьте число на 20, округлите его, и разделите на 20: Round(20 * [МоеПоле], 0) / 20

Подобным образом, чтобы округлить до ближайшего четвертака, умножьте на 4, округлите, и разделите на 4: Round(4 * [МоеПоле], 0) / 4

Округлить до 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().

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

Зачем округлять?

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

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

Это также относится и к денежным полям. Аксесс отображает денежные поля округленными до ближайшей копейки, но хранит их значение до сотой доли копейки (4 знака после запятой.)

Банковское округление

Функция Round() в Аксессе использует «банковское округление». Когда последней значащей цифрой оказывается 5, она округляет до ближайшего четной цифры. Так, 0,125 округляется до 0,12 (2 четно), в то время как 0,135 округляется до 0,14 (4 четно.)

Главный смысл здесь — равенство: 1,2,3, и 4 округляются вниз. 6,7,8, и 9 — вверх. 0 не требует округления. Так, если 5 все время округлять вверх, вы получите «сдвинутые» результаты — 4 цифры округляются вниз, и 5 вверх. Чтобы избежать этого, «третий лишний» (5) округляется в соответствии с предыдущей цифрой, что сглаживает неравенство.

Если вы не хотите использовать банковское округление, возьмите функцию Кена Гетца (ссылка вверху.)

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

Дробные величины компьютер обычно трактует как числа с плавающей точкой. Аксессовские поля типов Двойной точности (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), если вам нужно больше знаков после запятой.

Округление дат и времени

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

Функция ниже округляет дату/время до указанного количества секунд. Например, чтобы округлить до ближайшего получаса (30 * 60 seconds), используйте: =RoundTime([МоеПолеДатаВремя], 1800)

Public Function RoundTime(varTime As Variant, Optional ByVal lngSeconds As Long = 900&) As Variant Dim lngSecondsOffset As Long RoundTime = Null If Not IsError(varTime) Then If IsDate(varTime) Then If (lngSeconds < 1&) Or (lngSeconds > 86400) Then lngSeconds = 1& End If lngSecondsOffset = lngSeconds * CLng(DateDiff(«s», #12:00:00 AM#, TimeValue(varTime)) / lngSeconds) RoundTime = DateAdd(«s», lngSecondsOffset, DateValue(varTime)) End If End If

End Function

Заключение

Для более детального технического объяснения теории округления в целом, см. статью Клайва Максфилда (Clive Maxfield) An introduction to different rounding algorithms.

Источник: http://alx-artamonov.narod.ru/index/0-7

Методы округления чисел в JavaScript

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

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

0.1 * 0.2;
> 0.020000000000000004

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

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

если для toFixed() аргумент не определен, значение по умолчанию равно 0, то есть без знаков после запятой; максимальное значение аргумента равно 20;
если для toPrecision() аргумент не задан, число не изменяется.

var randNum = 6.25;
randNum.toFixed();
> «6»

Math.PI.toPrecision(1);
> «3»

var randNum = 87.335;
randNum.toFixed(2);
> «87.33»

var randNum = 87.337;
randNum.toPrecision(3);
> «87.3»

Примечание

И toFixed(), и toPrecision возвращают округленное строчное представление результата, а не число. Это означает, что прибавление rounded к randNum в результате даст конкатенацию строк, а не одно число:

console.log(randNum + rounded);
> «6.256»

Если нужно получить в результате JavaScript округления до сотых число, используйте parseFloat():

var randNum = 6.25;
var rounded = parseFloat(randNum.toFixed(1));
console.log(rounded);
> 6.3

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

var wholeNum = 1
var dollarsCents = wholeNum.toFixed(2);
console.log(dollarsCents);
> «1.00»

Обратите внимание, что если в числе больше знаков, чем задано параметром точности, toPrecision будет выдавать результат в научном формате:

var num = 123.435
num.toPrecision(2);
> «1.2e+2»

В некоторых случаях toFixed и toPrecision осуществляют JavaScript округление 5 в меньшую сторону, а не до большего:

var numTest = 1.005;
numTest.toFixed(2);
> 1;

Результатом приведенного выше примера должно быть 1.01, а не 1. Если нужно избежать этой ошибки, я рекомендую использовать экспоненциальные числа:

function round(value, decimals) {
return Number(Math.round(value+'e'+decimals)+'e-'+decimals);
}

Применение:

Если нужно еще более надежное решение, чем округление, оно доступно на MDN.

Альтернативный метод JavaScript округления до десятых был введен в ES6 (также известном, как JavaScript 2015). «Машинный эпсилон» обеспечивает разумный предел погрешности при сравнении двух чисел с плавающей запятой. Без округления, сравнения могут дать результаты, подобные следующим:

0.1 + 0.2 === 0.3
> false

Math.EPSILON может быть использован в функции для получения корректного сравнения:

function epsEqu(x, y) {
return Math.abs(x — y) < Number.EPSILON * Math.max(Math.abs(x), Math.abs(y)); }

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

epsEqu(0.1 + 0.2, 0.3)
> true

Все современные браузеры поддерживают математические функции ES6. Но если необходимо обеспечить поддержку в старых браузерах, то нужно использовать полифиллы.

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

function truncated(num) {
return Math.trunc(num * 100) / 100;
}
truncated(3.1416)
> 3.14

Если требуется что-то более гибкое, можно воспользоваться побитовым оператором:

function truncated(num, decimalPlaces) {
var numPowerConverter = Math.pow(10, decimalPlaces);
return ~~(num * numPowerConverter)/numPowerConverter;
}

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

var randInt = 35.874993;
truncated(randInt,3);
> 35.874

Чтобы осуществить JavaScript округление до целого, используется Math.round():

Math.round(4.3)
> 4
Math.round(4.5)
> 5

Обратите внимание, что «половинные значения«, такие как .5, округляются вверх.

Если вы хотите округлять в меньшую сторону, используйте метод Math.floor():

Math.floor(42.23);
> 42
Math.floor(36.93);
> 36

Округление «вниз» имеет одно направление для всех чисел, в том числе и для отрицательных. Это можно представить, как небоскреб с бесконечным количеством этажей, в том числе и ниже уровня фундамента (представляющих отрицательные числа). Если вы находитесь в лифте между подвальными этажами 2 и 3 (что соответствует значению -2.5), Math.floor доставит вас на этаж -3:

Если нужно избежать этого, используйте JavaScript Math округление с помощью Math.trunc(), поддерживаемый во всех современных браузерах (кроме IE / Edge):

Math.trunc(-41.43);
> -41

MDN также предоставляет полифилл из трех строк для обеспечения поддержки Math.trunc в старых браузерах и IE / Edge.

Если вы хотите округлить десятичные числа вверх, используйте Math.ceil. Действие этого метода также можно представить, как бесконечный лифт: Math.ceil всегда везет вас «вверх«, независимо от того, является ли число отрицательным или положительным:

Math.ceil(42.23);
> 43
Math.ceil(36.93);
> 37
Math.ceil(-36.93); -36

Если нужно округлить значение до ближайшего числа, кратного 5, создайте функцию, которая делит число на 5, округляет его, а затем умножает результат на то же значение:

function roundTo5(num) {
return Math.round(num/5)*5;
}

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

Если нужно выполнить JavaScript округление до двух знаков, можно передавать функции, как начальное число, так и кратность:

function roundToMultiple(num, multiple) {
return Math.round(num/multiple)*multiple;
}

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

var initialNumber = 11;
var multiple = 10;
roundToMultiple(initialNumber, multiple);
> 10;

Чтобы округлять значения только в большую или меньшую сторону замените в функции round на ceil или floor.

Иногда нужно получить значение х, которое должно находиться в пределах определенного диапазона. Например, нужно значение от 1 до 100, но мы получаем значение 123. Чтобы исправить это, можно использовать min() (возвращает наименьшее из чисел) и max (возвращает максимально допустимое число).

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

var lowBound = 1;
var highBound = 100;
var numInput = 123;
var clamped = Math.max(lowBound, Math.min(numInput, highBound));
console.log(clamped);
> 100;

Можно создать функцию или расширение класса Number:

Number.prototype.clamp = function(min, max) {
return Math.min(Math.max(this, min), max);
};

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

(numInput).clamp(lowBound, highBound);

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

Примеры использования:

gaussRound(2.5)
> 2

gaussRound(3.5)
> 4

gaussRound(2.57,1)
> 2.6

Так как JavaScript часто используется для получения информации о позиции или преобразования HTML-элементов, то можно задаться вопросом, что произойдет, если мы сгенерируем десятичные значения для элементов:

#box { width: 63.667731993px; }

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

Данная публикация представляет собой перевод статьи «JavaScript Rounding Recipes» , подготовленной дружной командой проекта Интернет-технологии.ру

Источник: https://www.internet-technologies.ru/articles/metody-okrugleniya-chisel-v-javascript.html

Функция ОКРУГЛ (пользовательское веб-приложение для Access)

09/05/2017
Время чтения: 2 мин

Возвращает числовое значение, которое округляется или усекается до указанной длины или точности.Returns a numeric value, either rounded or truncated, to the specified length or precision.

Важно!

Корпорация Майкрософт в настоящее время не рекомендует создавать и использовать веб-приложения Access в SharePoint.Microsoft no longer recommends creating and using Access web apps in SharePoint.

В качестве альтернативы можно использовать Microsoft PowerApps для создания бизнес-решений без кода для Интернета и мобильных устройств.

As an alternative, consider using Microsoft PowerApps to build no-code business solutions for the web and mobile devices.

СинтаксисSyntax

Round (круглый ) (Число, точность , [ трункатеинстеадофраунд ])Round (Number, Precision , [ TruncateInsteadOfRound ])

Функция ОКРУГЛ содержит следующие аргументы:The Round function contains the following arguments.

Имя аргументаArgument name
ОписаниеDescription

NumberNumber	Числовое выражение.A numeric expression.
ТочностиPrecision	Точность округления числа .The precision to which Number is to be rounded. Точность должна быть числовым выражением.Precision must be a numeric expression. Если точность является положительным числом, то число округляется до количества десятичных позиций, заданных по длине.When Precision is a positive number, Number is rounded to the number of decimal positions specified by length. Если точность является отрицательным числом, то число округляется в левой части десятичной точки, как указано по значению length.When Precision is a negative number, Number is rounded on the left side of the decimal point, as specified by length.
ТрункатеинстеадофраундTruncateInsteadOfRound	Тип выполняемой операции.The type of operation to perform. Если этот параметр опущен или не задано значение 0, то число округляется.When omitted or set to 0, Number is rounded. Если указано значение, отличное от 0, число усекается.When a value other than 0 is specified, Number is truncated. Значение по умолчанию равно 0.The default value is 0.

Функция Round всегда возвращает значение.Round always returns a value. Если длина имеет отрицательное значение, превышающее количество цифр до запятой, то функция Round возвращает 0.If length is negative and larger than the number of digits before the decimal point, Round returns 0.

Источник: https://docs.microsoft.com/ru-ru/office/client-developer/access/round-function-access-custom-web-app

Оценка статьи: