// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at <https://mozilla.org/MPL/2.0/>.
+import { call } from "./function.js";
+import {
+ stringCatenate,
+ stringPadEnd,
+ stringRepeat,
+ substring,
+ toString,
+} from "./string.js";
import { sameValue, toPrimitive } from "./value.js";
export const {
isSafeInteger: isSafeIntegralNumber,
} = Number;
+/** Positive zero. */
+export const POSITIVE_ZERO = 0;
+
+/** Negative zero. */
+export const NEGATIVE_ZERO = -0;
+
/**
* Returns the magnitude (absolute value) of the provided value.
*
? n === 0n ? 0n : n < 0n ? -1n : 1n
: isNan(n) || n === 0
? n
- : //deno-lint-ignore no-compare-neg-zero
- n < -0
- ? -1
- : 1;
+ //deno-lint-ignore no-compare-neg-zero
+ : n < -0
+ ? -1
+ : 1;
};
/**
return { toBigInt: ($) => makeBigInt($) };
})();
+export const {
+ /**
+ * Returns the result of converting the provided value to an
+ * exponential notation string.
+ *
+ * If a second argument is provided, it gives the number of
+ * fractional digits to use in the mantissa. Otherwise, the smallest
+ * number which does not result in a reduction in precision is used.
+ *
+ * ※ This method is safe to use with big·ints.
+ */
+ toExponentialNotation,
+
+ /**
+ * Returns the result of converting the provided value to a fixed
+ * decimal notation string with the provided number of fractional
+ * digits.
+ *
+ * ※ This method is safe to use with big·ints.
+ */
+ toFixedDecimalNotation,
+} = (() => {
+ const {
+ toExponential: numberToExponential,
+ toFixed: numberToFixed,
+ } = Number.prototype;
+ const { toString: bigintToString } = BigInt.prototype;
+ return {
+ toExponentialNotation: ($, fractionDigits) => {
+ const n = toNumeric($);
+ const f = toIntegralNumberOrInfinity(fractionDigits);
+ if (!isFiniteNumber(f) || f < 0 || f > 100) {
+ throw new RangeError(
+ `Piscēs: The number of fractional digits must be a finite number between 0 and 100 inclusive; got: ${f}.`,
+ );
+ } else {
+ if (typeof n === "number") {
+ return call(
+ numberToExponential,
+ n,
+ [fractionDigits === undefined ? fractionDigits : f],
+ );
+ } else {
+ const digits = call(bigintToString, n, [10]);
+ const { length } = digits;
+ if (fractionDigits === undefined) {
+ return length === 1
+ ? `${digits[0]}e+0`
+ : `${digits[0]}.${substring(digits, 1)}e+${length - 1}`;
+ } else if (f === 0) {
+ return `${digits[0]}e+0`;
+ } else {
+ const fractionalPart = toString(
+ round(
+ +stringCatenate(
+ stringPadEnd(substring(digits, 1, f + 1), f, "0"),
+ ".",
+ digits[f + 1] || "0",
+ ),
+ ),
+ );
+ return `${digits[0]}.${fractionalPart}e+${length - 1}`;
+ }
+ }
+ }
+ },
+ toFixedDecimalNotation: ($, fractionDigits) => {
+ const f = toIntegralNumberOrInfinity(fractionDigits);
+ if (!isFiniteNumber(f) || f < 0 || f > 100) {
+ throw new RangeError(
+ `Piscēs: The number of fractional digits must be a finite number between 0 and 100 inclusive; got: ${f}.`,
+ );
+ } else {
+ const n = toNumeric($);
+ if (typeof n === "number") {
+ return call(numberToFixed, n, [f]);
+ } else {
+ const digits = call(bigintToString, n, [10]);
+ return f === 0
+ ? digits
+ : `${digits}.${stringRepeat("0", f)}`;
+ }
+ }
+ },
+ };
+})();
+
export const {
/**
* Returns the result of converting the provided value to fit within
return {
toIntN: (n, $) => {
const prim = toPrimitive($);
- const big·int = toBigInt(prim);
- const intN = asIntN(n, big·int);
- return typeof prim === "bigint" ? intN : toNumber(intN);
+ if (typeof prim === "bigint") {
+ // The primitive value is a big·int.
+ return asIntN(n, prim);
+ } else {
+ // The primitive value is not a big·int.
+ const int = trunc(prim);
+ if (!isFiniteNumber(int) || int == 0) {
+ // The truncated value is zero or not finite.
+ return 0;
+ } else {
+ // The truncated value is finite.
+ return toNumber(asIntN(n, toBigInt(int)));
+ }
+ }
},
toUintN: (n, $) => {
const prim = toPrimitive($);
- const big·int = toBigInt(prim);
- const uintN = asUintN(n, big·int);
- return typeof prim === "bigint" ? uintN : toNumber(uintN);
+ if (typeof prim === "bigint") {
+ // The primitive value is a big·int.
+ return asUintN(n, prim);
+ } else {
+ // The primitive value is not a big·int.
+ const int = trunc(prim);
+ if (!isFiniteNumber(int) || int == 0) {
+ // The truncated value is zero or not finite.
+ return 0;
+ } else {
+ // The truncated value is finite.
+ return toNumber(asUintN(n, toBigInt(int)));
+ }
+ }
},
};
})();
+/**
+ * Returns the result of converting the provided number to an integral
+ * number.
+ *
+ * ※ This function will never return negative zero.
+ */
+export const toIntegralNumber = ($) => {
+ const n = toIntegralNumberOrInfinity($);
+ return !isFiniteNumber(n) || n == 0 ? 0 : n;
+};
+
/**
* Returns the result of converting the provided number to an integer
* or infinity.
*
- * ☡ This function does not allow big·int arguments.
+ * ※ Unlike the ToIntegerOrInfinity function defined in the Ecmascript
+ * specification, this function is safe to use with big·ints. However,
+ * the result will always be a number.
+ *
+ * ※ This function will never return negative zero.
*/
-export const toIntegerOrInfinity = ($) => {
- const integer = trunc($);
+export const toIntegralNumberOrInfinity = ($) => {
+ const integer = trunc(toNumber($));
if (isNan(integer) || integer == 0) {
// The provided value truncs to nan or (positive or negative) zero.
return 0;
/**
* Returns the result of converting the provided value to a number.
*
- * ※ This method is safe to use with big·ints.
+ * ※ This function is safe to use with big·ints.
*
* ※ This is effectively a nonconstructible version of the Number
* constructor.
Lady’s Gitweb / Pisces / blobdiff