ECMAScript | Тип Number

Тип Number имеет ровно 18,437,736,874,454,810,627 (то есть 264 — 253 + 3) значений, представляющих значения IEEE 754-2019 в 64-битном формате двойной точности, как указано в стандарте IEEE для двоичной арифметики с плавающей запятой, за исключением того, что 9,007,199,254,740,990 (то есть 253 — 2) отдельные значения «не числа (Not-a-Number)» стандарта IEEE представлены в ECMAScript как одно специальное значение NaN. (Обратите внимание, что значение NaN создается программным выражением NaN.) В некоторых реализациях внешний код может обнаруживать разницу между различными значениями Not-a-Number, но такое поведение определяется реализацией; в коде ECMAScript все значения NaN неотличимы друг от друга.

Примечание

Битовый шаблон, который может наблюдаться в ArrayBuffer (см. 25.1) или SharedArrayBuffer (см. 25.2) после сохранения в нем числового значения, не обязательно совпадает с внутренним представлением этого числового значения, используемым реализацией ECMAScript.

Есть два других особых значения: положительная бесконечность (positive Infinity) и отрицательная бесконечность (negative Infinity). Для краткости эти значения также обозначаются символами +∞𝔽 и -∞𝔽 соответственно с целью пояснения. (Обратите внимание, что эти два бесконечных числовых значения создаются программными выражениями +Infinity (или просто Infinity) и -Infinity.)

Остальные 18,437,736,874,454,810,624 (такие как 264 — 253) значения называются конечными числами (finite numbers). Половина из них — положительные числа, а половина — отрицательные числа; для каждого конечного положительного значения Number существует соответствующее отрицательное значение, имеющее ту же величину.

Обратите внимание, что есть как положительный ноль (positive zero), так и отрицательный ноль (negative zero). Для краткости эти значения также обозначаются символами +0𝔽 и -0𝔽 соответственно с целью пояснения. (Обратите внимание, что эти два разных нулевых числовых значения создаются программными выражениями +0 (или просто 0) и -0.)

The 18,437,736,874,454,810,622 (которые являются, 264 — 253 — 2) конечных ненулевых значений бывают двух видов:

18,428,729,675,200,069,632 (that is, 264 — 254) из них нормированные, имеющие вид

s × m × 2e

где s равно 1 или -1, mцелое число, такое что 252 ≤ m < 253, а eцелое число, такое, что -1074 ≤ e ≤ 971.

Остальные 9,007,199,254,740,990 (то есть 253 — 2) значений денормализованы и имеют вид

s × m × 2e

где s равно 1 или -1, mцелое число, такое что 0 < m < 252, а e равно -1074.

Обратите внимание, что все положительные и отрицательные целые числа, величина которых не превышает 253, могут быть представлены в типе Number. Целое число 0 имеет два представления в типе Number: +0𝔽 и -0𝔽.

Конечное число имеет нечетное значение (odd significand), если оно не равно нулю и целое число m, используемое для его выражения (в одной из двух форм, показанных выше), нечетное. В противном случае он имеет чётное значение (even significand).

В этой спецификации фраза «Числовое значение для x», где x представляет собой точную реальную математическую величину (которая может быть даже иррациональным числом, например π), означает Числовое Значение, выбранное следующим образом. Рассмотрим набор всех конечных значений типа Number, с удаленным -0𝔽 и добавленными к нему двумя дополнительными значениями, которые не могут быть представлены в типе Number, а именно 21024 (что составляет +1 × 253 × 2971) и -21024 (что равно -1 × 253 × 2971). Выберите член этого набора, наиболее близкий по значению к x. Если два значения набора одинаково близки, то выбирается одно с четным значением; для этой цели два дополнительных значения 21024 и -21024 считаются имеющими четные значения. Наконец, если был выбран 21024, замените его на +∞𝔽; если было выбрано -21024, замените его на -∞𝔽; если было выбрано +0𝔽, замените его на -0𝔽 тогда и только тогда, когда x < 0; любое другое выбранное значение используется без изменений. Результатом является Числовое Значение для x. (Эта процедура точно соответствует поведению режима roundTiesToEven стандарта IEEE 754-2019.)

Числовое Значение для +∞ равно +∞𝔽, а Числовое Значение для -∞ равно -∞𝔽.

Некоторые операторы ECMAScript имеют дело только с целыми числами в определенных диапазонах, например от -231 до 231 — 1 включительно или в диапазоне от 0 до 216 — 1 включительно. Эти операторы принимают любое значение типа Number, но сначала преобразуют каждое такое значение в целочисленное значение в ожидаемом диапазоне. Смотри описание операций преобразования чисел в разделе 7.1.

Значение Number::unit равно 1𝔽.

 

6.1.6.1.1 Number::unaryMinus ( x )
6.1.6.1.2 Number::bitwiseNOT ( x )
6.1.6.1.3 Number::exponentiate ( base, exponent )
6.1.6.1.4 Number::multiply ( x, y )
6.1.6.1.5 Number::divide ( x, y )
6.1.6.1.6 Number::remainder ( n, d )
6.1.6.1.7 Number::add ( x, y )
6.1.6.1.8 Number::subtract ( x, y )
6.1.6.1.9 Number::leftShift ( x, y )
6.1.6.1.10 Number::signedRightShift ( x, y )
6.1.6.1.11 Number::unsignedRightShift ( x, y )
6.1.6.1.12 Number::lessThan ( x, y )
6.1.6.1.13 Number::equal ( x, y )
6.1.6.1.14 Number::sameValue ( x, y )
6.1.6.1.15 Number::sameValueZero ( x, y )
6.1.6.1.16 NumberBitwiseOp ( op, x, y )
6.1.6.1.17 Number::bitwiseAND ( x, y )
6.1.6.1.18 Number::bitwiseXOR ( x, y )
6.1.6.1.19 Number::bitwiseOR ( x, y )
6.1.6.1.20 Number::toString ( x )

6.1.6.1.1 Number::unaryMinus ( x )

Абстрактная операция Number::unaryMinus принимает аргумент x (Число). При вызове она выполняет следующие шаги:

1. Если x равен NaN, вернуть NaN.
2. Вернуть результат отрицания x; то есть вычислить Число с той же величиной, но с противоположным знаком.

 

6.1.6.1.2 Number::bitwiseNOT ( x )

Абстрактная операция Number::bitwiseNOT принимает аргумент x (Число). При вызове она выполняет следующие шаги:

1. Пусть oldValue будет ! ToInt32(х).
2. Вернуть результат применения побитового дополнения к oldValue. Математическое значение результата точно можно представить в виде 32-битной битовой строки с дополнением до двух.

 

6.1.6.1.3 Number::exponentiate ( base, exponent )

Абстрактная операция Number::exponentiate принимает аргументы base (Число) и exponent (Число). Она возвращает приближенное к реализации значение, представляющее результат возведения основания в степень экспоненты. При вызове она выполняет следующие шаги:

1. Если показатель степени exponent равен NaN, вернуть NaN.
2. Если показатель степени exponent равен +0𝔽 или показатель степени exponent равен -0𝔽, вернуть 1𝔽.
3. Если база base равна NaN, вернуть NaN.
4. Если база base равна +∞𝔽, то
   а. Если exponent > +0𝔽, вернуть +∞𝔽. В противном случае верните +0𝔽.
5. Если base равна -∞𝔽, то
   а. Если exponent > +0𝔽, то
      i. Если exponent является нечетным целым Числом, верните -∞𝔽. В противном случае верните +∞𝔽.
   b. Иначе,
      i. Если exponent является нечетным целым Числом, верните -0𝔽. В противном случае верните +0𝔽.
6. Если base является +0𝔽, то
   а. Если exponent > +0𝔽, верните +0𝔽. В противном случае верните +∞𝔽.
7. Если base является -0𝔽, то
   а. Если exponent > +0𝔽, то
      i. Если exponent является нечетным целым Числом, верните -0𝔽. В противном случае верните +0𝔽.
   b. Иначе,
      i. Если exponent является нечетным целым Числом, верните -∞𝔽. В противном случае верните +∞𝔽.
8. Утверждено: base конечна и не равна ни +0𝔽, ни -0𝔽.
9. Если exponent равен +∞𝔽, то
   а. Если abs( (base)) > 1, вернуть +∞𝔽.
   b. Если abs( (base)) равно 1, вернуть NaN.
   c. Если abs( (base)) < 1, вернуть +0𝔽.
10. Если exponent равен -∞𝔽, то
   а. Если abs( (base)) > 1, вернуть +0𝔽.
   b. Если abs( (base)) равно 1, вернуть NaN.
   c. Если abs( (base)) < 1, вернуть +∞𝔽.
11. Утверждено: exponent конечен и не равен ни +0𝔽, ни -0𝔽.
12. Если base < +0𝔽 и exponent не является целым Числом, верните NaN.
13. Верните значение, приближенное к реализации, представляющее результат возведения (base) в степень (exponent).
Примечание

Результат base ** exponent, когда base равно 1𝔽 или -1𝔽, а exponent равно +∞𝔽 или -∞𝔽, или когда base равно 1𝔽, а exponent является NaN, отличается от IEEE 754-2019. Первая редакция ECMAScript определяла результат NaN для этой операции, тогда как более поздние версии IEEE 754-2019 указывали 1𝔽. Историческое поведение ECMAScript сохраняется по соображениям совместимости.

 

6.1.6.1.4 Number::multiply ( x, y )

Абстрактная операция Number::multiply принимает аргументы x (число) и y (число). Он выполняет умножение в соответствии с правилами двоичной арифметики двойной точности IEEE 754-2019, производя произведение x и y. При вызове она выполняет следующие шаги:

1. Если x равно NaN или y равно NaN, вернуть NaN.
2. Если x равен + ∞𝔽 или x равен -∞𝔽, то
а. Если y равно + 0𝔽 или y равно -0𝔽, вернуть NaN.
б. Если y> + 0𝔽, вернуть x.
c. Вернуть -x.
3. Если y равно + ∞𝔽 или y равно -∞𝔽, то
а. Если x равен + 0𝔽 или x равен -0𝔽, вернуть NaN.
б. Если x> + 0𝔽, верните y.
c. Возврат -у.
4. Верните 𝔽 (ℝ (x) × ℝ (y)).

Примечание

Умножение конечной точности коммутативно, но не всегда ассоциативно.

 

6.1.6.1.5 Number::divide ( x, y )

Абстрактная операция Number :: div принимает аргументы x (число) и y (число). Он выполняет деление в соответствии с правилами двоичной арифметики двойной точности IEEE 754-2019, производя частное x и y, где x — делимое, а y — делитель. При вызове он выполняет следующие шаги:

1. Если x равно NaN или y равно NaN, вернуть NaN.
2. Если x равен + ∞𝔽 или x равен -∞𝔽, то
а. Если y равно + ∞𝔽 или y равно -∞𝔽, вернуть NaN.
б. Если y равно + 0𝔽 или y> + 0𝔽, вернуть x.
c. Вернуть -x.
3. Если y равно + ∞𝔽, то
а. Если x равно + 0𝔽 или x> + 0𝔽, верните + 0𝔽. В противном случае верните -0𝔽.
4. Если y равно -∞𝔽, то
а. Если x равно + 0𝔽 или x> + 0𝔽, верните -0𝔽. В противном случае верните + 0𝔽.
5. Если x равен + 0𝔽 или x равен -0𝔽, то
а. Если y равно + 0𝔽 или y равно -0𝔽, вернуть NaN.
б. Если y> + 0𝔽, вернуть x.
c. Вернуть -x.
6. Если y равно + 0𝔽, то
а. Если x> + 0𝔽, вернуть + ∞𝔽. В противном случае верните -∞𝔽.
7. Если y равно -0𝔽, то
а. Если x> + 0𝔽, верните -∞𝔽. В противном случае верните + ∞𝔽.
8. Верните 𝔽 (ℝ (x) / ℝ (y)).

 

6.1.6.1.6 Number::remainder ( n, d )

Абстрактная операция Число :: остаток принимает аргументы n (Число) и d (Число). Он дает остаток от подразумеваемого деления своих операндов, где n — дивиденд, а d — делитель. При вызове он выполняет следующие шаги:

1. Если n равно NaN или d равно NaN, вернуть NaN.
2. Если n равно + ∞𝔽 или n равно -∞𝔽, вернуть NaN.
3. Если d равно + ∞𝔽 или d равно -∞𝔽, вернуть n.
4. Если d равно + 0𝔽 или d равно -0𝔽, вернуть NaN.
5. Если n равно + 0𝔽 или n равно -0𝔽, вернуть n.
6. Утверждение: n и d конечны и не равны нулю.
7. Пусть r равно ℝ (n) — (ℝ (d) × q), где q — целое число, отрицательное тогда и только тогда, когда n и d имеют противоположный знак, и величина которого настолько велика, насколько это возможно, но не превышает величину ℝ (п) / ℝ (г).
8. Верните 𝔽 (r).

Примечание 1

В C и C ++ оператор остатка принимает только целые операнды; в ECMAScript он также принимает операнды с плавающей запятой.

Примечание 2

Результат операции остатка с плавающей запятой, вычисленный оператором%, не совпадает с результатом операции «остаток», определенной в IEEE 754-2019. Операция «остаток» IEEE 754-2019 вычисляет остаток от деления округления, а не от деления усечения, поэтому ее поведение не аналогично поведению обычного оператора целочисленного остатка. Вместо этого язык ECMAScript определяет% для операций с плавающей запятой, чтобы вести себя аналогично оператору целочисленного остатка Java; это можно сравнить с функцией библиотеки C fmod.

 

6.1.6.1.7 Number::add ( x, y )

Абстрактная операция Number :: add принимает аргументы x (число) и y (число). Он выполняет сложение в соответствии с правилами двоичной арифметики двойной точности IEEE 754-2019, производя сумму своих аргументов. При вызове он выполняет следующие шаги:

1. Если x равно NaN или y равно NaN, вернуть NaN.
2. Если x равно + ∞𝔽, а y равно -∞𝔽, вернуть NaN.
3. Если x равен -∞𝔽, а y равен + ∞𝔽, вернуть NaN.
4. Если x равен + ∞𝔽 или x равен -∞𝔽, вернуть x.
5. Если y равно + ∞𝔽 или y равно -∞𝔽, верните y.
6. Утверждение: x и y конечны.
7. Если x равен -0𝔽, а y равен -0𝔽, верните -0𝔽.
8. Верните 𝔽 (ℝ (x) + ℝ (y)).

Примечание

Сложение конечной точности коммутативно, но не всегда ассоциативно.

 

6.1.6.1.8 Number::subtract ( x, y )

Абстрактная операция Number :: subtract принимает аргументы x (число) и y (число). Он выполняет вычитание, производя разность своих операндов; x — это уменьшенное, а y — вычитаемое. При вызове он выполняет следующие шаги:

1. Вернуть Number::add(x, Number::unaryMinus(y)).

Примечание

Всегда бывает так, что x — y дает тот же результат, что и x + (-y).

 

6.1.6.1.9 Number::leftShift ( x, y )

Абстрактная операция Number :: leftShift принимает аргументы x (число) и y (число). При вызове он выполняет следующие шаги:

1. Пусть будет lnum! ToInt32 (х).
2. Да будет рнум! ToUint32 (у).
3. Пусть shiftCount равно (rnum) по модулю 32.
4. Вернуть результат сдвига влево lnum битами shiftCount. Математическое значение результата точно можно представить в виде 32-битной битовой строки с дополнением до двух.

 

6.1.6.1.10 Number::signedRightShift ( x, y )

Абстрактная операция Number :: signedRightShift принимает аргументы x (число) и y (число). При вызове он выполняет следующие шаги:

1. Пусть будет lnum! ToInt32 (х).
2. Да будет рнум! ToUint32 (у).
3. Пусть shiftCount равно (rnum) по модулю 32.
4. Вернуть результат выполнения сдвига вправо lnum с расширением знака на бит shiftCount. Распространяется самый старший бит. Математическое значение результата точно можно представить в виде 32-битной битовой строки с дополнением до двух.

 

6.1.6.1.11 Number::unsignedRightShift ( x, y )

Абстрактная операция Number :: unsignedRightShift принимает аргументы x (число) и y (число). При вызове он выполняет следующие шаги:

1. Пусть будет lnum! ToUint32 (х).
2. Да будет рнум! ToUint32 (у).
3. Пусть shiftCount равно (rnum) по модулю 32.
4. Вернуть результат выполнения сдвига lnum вправо с заполнением нулями на биты shiftCount. Освободившиеся биты заполняются нулями. Математическое значение результата точно можно представить в виде 32-битной беззнаковой битовой строки.

 

6.1.6.1.12 Number::lessThan ( x, y )

Абстрактная операция Number :: lessThan принимает аргументы x (число) и y (число). При вызове он выполняет следующие шаги:

1. Если x равен NaN, вернуть undefined.
2. Если y равно NaN, вернуть undefined.
3. Если x и y — одно и то же числовое значение, вернуть false.
4. Если x равно + 0𝔽, а y равно -0𝔽, вернуть false.
5. Если x равен -0𝔽, а y равен + 0𝔽, вернуть false.
6. Если x равно + ∞𝔽, вернуть false.
7. Если y равно + ∞𝔽, вернуть истину.
8. Если y равно -∞𝔽, вернуть false.
9. Если x равен -∞𝔽, вернуть истину.
10. Утверждение: x и y конечны и не равны нулю.
11. Если ℝ (x) <ℝ (y), вернуть истину. В противном случае верните false.

 

6.1.6.1.13 Number::equal ( x, y )

Абстрактная операция Number :: equal принимает аргументы x (Число) и y (Число). При вызове он выполняет следующие шаги:

1. Если x равен NaN, вернуть false.
2. Если y равно NaN, вернуть false.
3. Если x совпадает с числовым значением y, вернуть истину.
4. Если x равно + 0𝔽, а y равно -0𝔽, вернуть истину.
5. Если x равен -0𝔽, а y равен + 0𝔽, вернуть истину.
6. Вернуть false.

 

6.1.6.1.14 Number::sameValue ( x, y )

Абстрактная операция Number :: sameValue принимает аргументы x (Число) и y (Число). При вызове он выполняет следующие шаги:

1. Если x равен NaN, а y равен NaN, вернуть true.
2. Если x равен + 0𝔽, а y равен -0𝔽, вернуть false.
3. Если x равен -0𝔽, а y равен + 0𝔽, вернуть false.
4. Если x имеет то же числовое значение, что и y, вернуть истину.
5. Вернуть false.

 

6.1.6.1.15 Number::sameValueZero ( x, y )

Абстрактная операция Number :: sameValueZero принимает аргументы x (число) и y (число). При вызове он выполняет следующие шаги:

1. Если x равен NaN, а y равен NaN, вернуть true.
2. Если x равно + 0𝔽, а y равно -0𝔽, вернуть истину.
3. Если x равен -0𝔽, а y равен + 0𝔽, вернуть истину.
4. Если x имеет то же числовое значение, что и y, вернуть истину.
5. Вернуть false.

 

6.1.6.1.16 NumberBitwiseOp ( op, x, y )

Абстрактная операция NumberBitwiseOp принимает аргументы op (&, ^ или |), x (число) и y (число). При вызове он выполняет следующие шаги:

1. Пусть будет lnum! ToInt32 (х).
2. Да будет рнум! ToInt32 (у).
3. Пусть lbits — это 32-битная строка битов дополнения до двух, представляющая ℝ (lnum).
4. Пусть rbits — это 32-битная битовая строка дополнения до двух, представляющая ℝ (rnum).
5. Если op равно &, пусть результат будет результатом применения побитовой операции И к lbit и rbits.
6. Иначе, если op равно ^, пусть результат будет результатом применения операции побитового исключающего ИЛИ (XOR) к lbits и rbits.
7. Иначе op is |. Пусть result будет результатом применения побитовой операции инклюзивного ИЛИ к lbits и rbits.
8. Верните числовое значение для целого числа, представленного результатом 32-битной строки двоичного дополнения.

 

6.1.6.1.17 Number::bitwiseAND ( x, y )

Абстрактная операция Number :: bitwiseAND принимает аргументы x (число) и y (число). При вызове он выполняет следующие шаги:

1. Вернуть NumberBitwiseOp(&, x, y).

 

6.1.6.1.18 Number::bitwiseXOR ( x, y )

Абстрактная операция Number :: bitwiseXOR принимает аргументы x (число) и y (число). При вызове он выполняет следующие шаги:

1. Вернуть NumberBitwiseOp(^, x, y).

 

6.1.6.1.19 Number::bitwiseOR ( x, y )

Абстрактная операция Number :: bitwiseOR принимает аргументы x (число) и y (число). При вызове он выполняет следующие шаги:

1. Вернуть NumberBitwiseOp(|, x, y).

 

6.1.6.1.20 Number::toString ( x )

Абстрактная операция Number :: toString принимает аргумент x (Число). Он преобразует x в формат String. При вызове он выполняет следующие шаги:

1. Если x равен NaN, вернуть строку «NaN».
2. Если x равен + 0𝔽 или -0𝔽, вернуть строку «0».
3. Если x <+ 0𝔽, вернуть конкатенацию строк «-» и! Число :: toString (-x).
4. Если x равно + ∞𝔽, верните строку «Infinity».
5. В противном случае, пусть n, k и s — целые числа такие, что k ≥ 1, 10k — 1 ≤ s <10k, 𝔽 (s × 10n — k) — это x, а k — как можно меньше. Обратите внимание, что k — это количество цифр в десятичном представлении s, что s не делится на 10 и что наименее значащая цифра s не обязательно однозначно определяется этими критериями.
6. Если k ≤ n ≤ 21, вернуть конкатенацию строк:
единицы кода k цифр десятичного представления s (по порядку, без ведущих нулей)
n — k вхождений кодовой единицы 0x0030 (DIGIT ZERO)
7. Если 0 <n ≤ 21, вернуть конкатенацию строк:
кодовые единицы старших n цифр десятичного представления s
блок кода 0x002E (ПОЛНАЯ ОСТАНОВКА)
кодовые единицы оставшихся k — n цифр десятичного представления s
8. Если -6 <n ≤ 0, вернуть конкатенацию строк:
кодовая единица 0x0030 (DIGIT ZERO)
блок кода 0x002E (ПОЛНАЯ ОСТАНОВКА)
-n вхождений кодовой единицы 0x0030 (ЦИФРОВОЙ НУЛЬ)
кодовые единицы k цифр десятичного представления s
9. В противном случае, если k = 1, вернуть конкатенацию строк:
кодовая единица одной цифры s
кодовый блок 0x0065 (СТРОЧНАЯ ЛАТИНСКАЯ БУКВА E)
кодовая единица 0x002B (ЗНАК ПЛЮС) или кодовая единица 0x002D (ДЕФИС-МИНУС) в зависимости от того, является ли n — 1 положительным или отрицательным
единицы кода десятичного представления целого числа abs (n — 1) (без ведущих нулей)
10. Верните конкатенацию строк:
кодовые единицы старшего разряда десятичного представления s
блок кода 0x002E (ПОЛНАЯ ОСТАНОВКА)
кодовые единицы оставшихся k — 1 цифры десятичного представления s
кодовый блок 0x0065 (СТРОЧНАЯ ЛАТИНСКАЯ БУКВА E)
кодовая единица 0x002B (ЗНАК ПЛЮС) или кодовая единица 0x002D (ДЕФИС-МИНУС) в зависимости от того, является ли n — 1 положительным или отрицательным
единицы кода десятичного представления целого числа abs (n — 1) (без ведущих нулей)

Примечание 1

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

Если x — любое числовое значение, отличное от -0𝔽, то ToNumber (ToString (x)) является точно таким же числовым значением, что и x.
Наименьшая значащая цифра s не всегда однозначно определяется требованиями, перечисленными в шаге 5.

Примечание 2

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

1. В противном случае, пусть n, k и s — целые числа такие, что k ≥ 1, 10k — 1 ≤ s <10k, 𝔽 (s × 10n — k) — это x, а k — как можно меньше. Если есть несколько возможностей для s, выберите значение s, для которого s × 10n — k наиболее близко по значению к ℝ (x). Если таких возможных значений s два, выберите четное. Обратите внимание, что k — это количество цифр в десятичном представлении s и что s не делится на 10.

Примечание 3

Разработчикам ECMAScript могут быть полезны статья и код, написанный Дэвидом М. Гейем для преобразования двоичных чисел в десятичные числа с плавающей запятой:

Гей, Дэвид М. Правильно округленные двоично-десятичные и десятично-двоичные преобразования. Численный анализ, рукопись 90-10. AT&T Bell Laboratories (Мюррей-Хилл, Нью-Джерси). 30 ноября 1990 г. Доступно как
http://ampl.com/REFS/abstracts.html#rounding. Связанный код доступен как
http://netlib.sandia.gov/fp/dtoa.c и как
http://netlib.sandia.gov/fp/g_fmt.c, а также его можно найти на различных сайтах-зеркалах netlib.

 

Информационные ссылки

Стандарт ECMAScript — Раздел «6.1.6.1 The Number Type» — https://tc39.es/ecma262/#sec-ecmascript-language-types-number-type

Поделись записью