@nberlette/math 0.7.0

package/esm/float16/guards.d.ts

@@ -0,0 +1,22 @@
+import type { Float16 } from "../types/float.js";
+/**
+ * Checks if a value is a valid {@linkcode Float16} as per IEEE 754-2008.
+ *
+ * @param it The value to check.
+ * @returns `true` if the value is a float16 number, `false` otherwise.
+ * @see https://en.wikipedia.org/wiki/Half-precision_floating-point_format
+ * @see https://en.wikipedia.org/wiki/IEEE_754
+ * @example
+ * ```ts
+ * import { isFloat16 } from "@nick/math/float16/guards";
+ *
+ * console.log(isFloat16(0.5)); // true
+ * console.log(isFloat16(0.1)); // false
+ * ```
+ * @see {@linkcode isFloat32} for a similar function for float32 numbers.
+ * @category Guards
+ * @tags float16
+ */
+export declare function isFloat16<N extends number>(it: N): it is Float16<N>;
+export declare function isFloat16(it: unknown): it is Float16<number>;
+//# sourceMappingURL=guards.d.ts.map

package/esm/float16/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/float16/guards.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;AACrE,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/esm/float16/guards.js

@@ -0,0 +1,12 @@
+/**
+ * This submodule provides type guards specific to the float16 module of the
+ * `@nick/math` library, namely the {@linkcode isFloat16} predicate function.
+ *
+ * @module float16/guards
+ */
+import { isNaN } from "../guards/nan.js";
+import { roundFloat16 } from "./round.js";
+export function isFloat16(it) {
+    return typeof it === "number" && !isNaN(it) && it === roundFloat16(it);
+}
+//# sourceMappingURL=guards.js.map

package/esm/float16/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float16/guards.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAsB1C,MAAM,UAAU,SAAS,CAAC,EAAW;IACnC,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,YAAY,CAAC,EAAE,CAAC,CAAC;AACzE,CAAC"}

package/esm/float16/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Utilities for working with `float16` values (16-bit half precision floating
+ * point numbers), as defined by IEEE 754-2008.
+ *
+ * @module float16
+ */
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./guards.js";
+export * from "./round.js";
+//# sourceMappingURL=index.d.ts.map

package/esm/float16/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/float16/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/esm/float16/index.js

@@ -0,0 +1,11 @@
+/**
+ * Utilities for working with `float16` values (16-bit half precision floating
+ * point numbers), as defined by IEEE 754-2008.
+ *
+ * @module float16
+ */
+export * from "./decode.js";
+export * from "./encode.js";
+export * from "./guards.js";
+export * from "./round.js";
+//# sourceMappingURL=index.js.map

package/esm/float16/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/float16/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC"}

package/esm/float16/round.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Rounds a number to the nearest 16-bit floating point value (half precision).
+ *
+ * Based on `Math.f16round` function from the TC39 Proposal for [Float16Array],
+ * which began shipping in ES2024, this function follows the same rounding and
+ * conversion rules as per the IEEE 754-2008 specification for half-precision
+ * floating-point numbers (also known as binary16).
+ *
+ * [Float16Array]: https://github.com/tc39/proposal-float16array
+ *
+ * @param x The number to round.
+ * @returns The 16-bit floating point rounded value of the number.
+ * @category Rounding
+ * @tags float, float16
+ * @example
+ * ```ts
+ * import { roundFloat16 } from "@nick/math/float16/round";
+ * import { PI } from "@nick/math/constants";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(roundFloat16(PI), 3.140625); // OK
+ * ```
+ */
+export declare function roundFloat16(x: number): number;
+//# sourceMappingURL=round.d.ts.map

package/esm/float16/round.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.d.ts","sourceRoot":"","sources":["../../src/float16/round.ts"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE9C"}

package/esm/float16/round.js

@@ -0,0 +1,43 @@
+/**
+ * This module provides functions for rounding numbers to 16-bit floating point
+ * values that follow the IEEE 754-2008 standard for half-precision binary16
+ * floating point numbers.
+ *
+ * The `roundFloat16` function rounds a number to the nearest 16-bit floating
+ * point value (half precision), following the same rounding and conversion
+ * rules as the native `Math.f16round` function from the TC39 Proposal for
+ * [Float16Array], which began shipping in ES2024.
+ *
+ * [Float16Array]: https://github.com/tc39/proposal-float16array
+ *
+ * @module float16/round
+ */
+import { encodeFloat16 } from "./encode.js";
+import { decodeFloat16 } from "./decode.js";
+/**
+ * Rounds a number to the nearest 16-bit floating point value (half precision).
+ *
+ * Based on `Math.f16round` function from the TC39 Proposal for [Float16Array],
+ * which began shipping in ES2024, this function follows the same rounding and
+ * conversion rules as per the IEEE 754-2008 specification for half-precision
+ * floating-point numbers (also known as binary16).
+ *
+ * [Float16Array]: https://github.com/tc39/proposal-float16array
+ *
+ * @param x The number to round.
+ * @returns The 16-bit floating point rounded value of the number.
+ * @category Rounding
+ * @tags float, float16
+ * @example
+ * ```ts
+ * import { roundFloat16 } from "@nick/math/float16/round";
+ * import { PI } from "@nick/math/constants";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(roundFloat16(PI), 3.140625); // OK
+ * ```
+ */
+export function roundFloat16(x) {
+    return decodeFloat16(encodeFloat16(+x));
+}
+//# sourceMappingURL=round.js.map

package/esm/float16/round.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"round.js","sourceRoot":"","sources":["../../src/float16/round.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAC5C,OAAO,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,YAAY,CAAC,CAAS;IACpC,OAAO,aAAa,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC1C,CAAC"}

package/esm/float32/constants.d.ts

@@ -0,0 +1,96 @@
+/**
+ * This module provides constants used by the encoding/decoding APIs in the
+ * `@nick/math/float32` suite. These are primarily used to handle special cases
+ * such as `NaN`, `Infinity`, and `-0`, which have unique representations in
+ * the IEEE-754 half-precision floating point format.
+ *
+ * These are intended for primarily internal use, but are exported for the sake
+ * of completeness and transparency, as well as for potential userland usage in
+ * cases where the constants are needed for custom encoding/decoding logic.
+ *
+ * @module float32/constants
+ */
+/**
+ * The number of bits used for the exponent in the IEEE-754 single-precision
+ * (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, exponent
+ */
+export declare const FLOAT32_EXPONENT_BITS = 8;
+/**
+ * The number of bits used for the mantissa in the IEEE-754 single-precision
+ * (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, mantissa
+ */
+export declare const FLOAT32_MANTISSA_BITS = 23;
+/**
+ * The exponent bias used in the IEEE-754 single-precision (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, exponent, bias
+ */
+export declare const FLOAT32_EXPONENT_BIAS = 127;
+/**
+ * Well-known bit pattern representing `NaN` in the IEEE-754 single-precision (or
+ * "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, NaN
+ */
+export declare const FLOAT32_NAN = 2143289344;
+/**
+ * Well-known bit pattern representing `+Infinity` (positive infinity) in the
+ * IEEE-754 single-precision (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, Infinity
+ */
+export declare const FLOAT32_POSITIVE_INFINITY = 2139095040;
+/**
+ * Well-known bit pattern representing `-Infinity` (negative infinity) in the
+ * IEEE-754 single-precision (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, Infinity
+ */
+export declare const FLOAT32_NEGATIVE_INFINITY = 4286578688;
+/**
+ * Well-known bit pattern representing `-0` (negative zero) in the IEEE-754
+ * single-precision (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, zero
+ */
+export declare const FLOAT32_NEGATIVE_ZERO = 2147483648;
+/**
+ * Well-known bit pattern representing `+0` (positive zero) in the IEEE-754
+ * single-precision (or "binary32") format.
+ *
+ * **Note**: This constant, unlike the others, is equivalent to its bit pattern
+ * representation (all bits are zero). As such, this is not strictly necessary
+ * for encoding/decoding, but is included for completeness and consistency.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, zero
+ */
+export declare const FLOAT32_POSITIVE_ZERO = 0;
+/**
+ * Represents the IEEE-754 binary32 (single-precision) floating-point format.
+ *
+ * @internal
+ */
+declare const _default: {
+    readonly exponent: 8;
+    readonly mantissa: 23;
+    readonly bias: 127;
+    readonly nan: 2143289344;
+    readonly positive_infinity: 2139095040;
+    readonly negative_infinity: 4286578688;
+    readonly negative_zero: 2147483648;
+    readonly positive_zero: 0;
+};
+export default _default;
+//# sourceMappingURL=constants.d.ts.map

package/esm/float32/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/float32/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,IAAI,CAAC;AAEvC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAK,CAAC;AAExC;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,aAAa,CAAC;AAEtC;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,aAAa,CAAC;AAEpD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,aAAa,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,IAAa,CAAC;AAEhD;;;;GAIG;;;;;;;;;;;AACH,wBASiC"}

package/esm/float32/constants.js

@@ -0,0 +1,95 @@
+/**
+ * This module provides constants used by the encoding/decoding APIs in the
+ * `@nick/math/float32` suite. These are primarily used to handle special cases
+ * such as `NaN`, `Infinity`, and `-0`, which have unique representations in
+ * the IEEE-754 half-precision floating point format.
+ *
+ * These are intended for primarily internal use, but are exported for the sake
+ * of completeness and transparency, as well as for potential userland usage in
+ * cases where the constants are needed for custom encoding/decoding logic.
+ *
+ * @module float32/constants
+ */
+/**
+ * The number of bits used for the exponent in the IEEE-754 single-precision
+ * (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, exponent
+ */
+export const FLOAT32_EXPONENT_BITS = 8;
+/**
+ * The number of bits used for the mantissa in the IEEE-754 single-precision
+ * (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, mantissa
+ */
+export const FLOAT32_MANTISSA_BITS = 23;
+/**
+ * The exponent bias used in the IEEE-754 single-precision (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, exponent, bias
+ */
+export const FLOAT32_EXPONENT_BIAS = 127;
+/**
+ * Well-known bit pattern representing `NaN` in the IEEE-754 single-precision (or
+ * "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, NaN
+ */
+export const FLOAT32_NAN = 0x7FC00000;
+/**
+ * Well-known bit pattern representing `+Infinity` (positive infinity) in the
+ * IEEE-754 single-precision (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, Infinity
+ */
+export const FLOAT32_POSITIVE_INFINITY = 0x7F800000;
+/**
+ * Well-known bit pattern representing `-Infinity` (negative infinity) in the
+ * IEEE-754 single-precision (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, Infinity
+ */
+export const FLOAT32_NEGATIVE_INFINITY = 0xFF800000;
+/**
+ * Well-known bit pattern representing `-0` (negative zero) in the IEEE-754
+ * single-precision (or "binary32") format.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, zero
+ */
+export const FLOAT32_NEGATIVE_ZERO = 0x80000000;
+/**
+ * Well-known bit pattern representing `+0` (positive zero) in the IEEE-754
+ * single-precision (or "binary32") format.
+ *
+ * **Note**: This constant, unlike the others, is equivalent to its bit pattern
+ * representation (all bits are zero). As such, this is not strictly necessary
+ * for encoding/decoding, but is included for completeness and consistency.
+ *
+ * @category Constants
+ * @tags float32, ieee-754, zero
+ */
+export const FLOAT32_POSITIVE_ZERO = 0x00000000;
+/**
+ * Represents the IEEE-754 binary32 (single-precision) floating-point format.
+ *
+ * @internal
+ */
+export default {
+    exponent: FLOAT32_EXPONENT_BITS,
+    mantissa: FLOAT32_MANTISSA_BITS,
+    bias: FLOAT32_EXPONENT_BIAS,
+    nan: FLOAT32_NAN,
+    positive_infinity: FLOAT32_POSITIVE_INFINITY,
+    negative_infinity: FLOAT32_NEGATIVE_INFINITY,
+    negative_zero: FLOAT32_NEGATIVE_ZERO,
+    positive_zero: FLOAT32_POSITIVE_ZERO,
+};
+//# sourceMappingURL=constants.js.map

package/esm/float32/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/float32/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC;AAEvC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,EAAE,CAAC;AAExC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC;AAEtC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;AAEpD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,UAAU,CAAC;AAEhD;;;;GAIG;AACH,eAAe;IACb,QAAQ,EAAE,qBAAqB;IAC/B,QAAQ,EAAE,qBAAqB;IAC/B,IAAI,EAAE,qBAAqB;IAC3B,GAAG,EAAE,WAAW;IAChB,iBAAiB,EAAE,yBAAyB;IAC5C,iBAAiB,EAAE,yBAAyB;IAC5C,aAAa,EAAE,qBAAqB;IACpC,aAAa,EAAE,qBAAqB;CACN,CAAC"}

package/esm/float32/decode.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Decodes a 32-bit unsigned integer (`Uint32`) into a 32-bit single-precision
+ * floating point value (`Float32`) with 23 bits of mantissa. This function
+ * follows the IEEE 754-2008 spec for single-precision floating point numbers.
+ *
+ * The input value is expected to be the result of an encoding operation, such
+ * as the value returned by the {@linkcode encodeFloat32} function, or by
+ * DataView's `getUint32` method when reading a single-precision float.
+ *
+ * This function is used internally by the {@linkcode fround} function to
+ * convert the intermediate value back into a standard JavaScript number.
+ *
+ * ## Special Cases
+ *
+ * The following special cases are handled separately, short-circuiting the
+ * decoding process to return a well-known constant value (as per IEEE spec):
+ *
+ * - `0x7FC00000` (2139095040) decodes to `NaN`
+ * - `0x7F800000` (2139095040) decodes to `+Infinity`
+ * - `0xFF800000` (4286578688) decodes to `-Infinity`
+ * - `0x80000000` (2147483648) decodes to `-0`
+ *
+ * @param bits The encoded 32-bit single-precision floating point value.
+ * @returns The decoded standard JavaScript number.
+ * @example
+ * ```ts
+ * import { decodeFloat32 } from "@nick/math/float32";
+ *
+ * console.log(decodeFloat32(0x40490FDB)); // 3.
+ *
+ * const view = new DataView(new Float32Array([3.14]).buffer);
+ * console.log(decodeFloat32(view.getUint32(0)));
+ * ```
+ * @category IEEE-754
+ * @tags float, float32, decode
+ */
+export declare function decodeFloat32(bits: number): number;
+//# sourceMappingURL=decode.d.ts.map

package/esm/float32/decode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.d.ts","sourceRoot":"","sources":["../../src/float32/decode.ts"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAElD"}

package/esm/float32/decode.js

@@ -0,0 +1,64 @@
+/**
+ * This module provides functions for decoding 32-bit single-precision floating
+ * point numbers (`Float32`) from IEEE 754-2008 encoded `Uint32` values, like
+ * those returned by {@linkcode encodeFloat32} or DataView's `geUint32` method.
+ *
+ * The `Float32` format is a 32-bit representation of a floating point number
+ * that follows the IEEE 754-2008 standard for single-precision binary32
+ * floating point numbers. This format is used to store floating point values
+ * in a DataView via `setUint32`, and is equivalent to the result of calling
+ * `DataView.prototype.getUint32` when reading a single-precision float.
+ *
+ * To encode a standard JavaScript number into a `Float32` value, use the
+ * {@linkcode encodeFloat32} function of the `./encode` module, passing it the
+ * number you want to encode. The result can then be stored in a DataView via
+ * `setUint32`, or used as an intermediate value for further processing.
+ *
+ *  To decode the `Float32` value back into a standard JavaScript number (but
+ * with 32-bits of precision), use the {@linkcode decodeFloat32} function of
+ * this module, passing it the encoded value.
+ *
+ * @module float32/decode
+ */
+import float32 from "./constants.js";
+import { decode } from "../internal/ieee754.js";
+/**
+ * Decodes a 32-bit unsigned integer (`Uint32`) into a 32-bit single-precision
+ * floating point value (`Float32`) with 23 bits of mantissa. This function
+ * follows the IEEE 754-2008 spec for single-precision floating point numbers.
+ *
+ * The input value is expected to be the result of an encoding operation, such
+ * as the value returned by the {@linkcode encodeFloat32} function, or by
+ * DataView's `getUint32` method when reading a single-precision float.
+ *
+ * This function is used internally by the {@linkcode fround} function to
+ * convert the intermediate value back into a standard JavaScript number.
+ *
+ * ## Special Cases
+ *
+ * The following special cases are handled separately, short-circuiting the
+ * decoding process to return a well-known constant value (as per IEEE spec):
+ *
+ * - `0x7FC00000` (2139095040) decodes to `NaN`
+ * - `0x7F800000` (2139095040) decodes to `+Infinity`
+ * - `0xFF800000` (4286578688) decodes to `-Infinity`
+ * - `0x80000000` (2147483648) decodes to `-0`
+ *
+ * @param bits The encoded 32-bit single-precision floating point value.
+ * @returns The decoded standard JavaScript number.
+ * @example
+ * ```ts
+ * import { decodeFloat32 } from "@nick/math/float32";
+ *
+ * console.log(decodeFloat32(0x40490FDB)); // 3.
+ *
+ * const view = new DataView(new Float32Array([3.14]).buffer);
+ * console.log(decodeFloat32(view.getUint32(0)));
+ * ```
+ * @category IEEE-754
+ * @tags float, float32, decode
+ */
+export function decodeFloat32(bits) {
+    return decode(bits, float32);
+}
+//# sourceMappingURL=decode.js.map

package/esm/float32/decode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"decode.js","sourceRoot":"","sources":["../../src/float32/decode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,OAAO,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;AAC/B,CAAC"}

package/esm/float32/encode.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Encodes a standard JavaScript number (a 64-bit double-precision floating
+ * point value, 52 bits of mantissa) into a 32-bit unsigned integer (Uint32).
+ * This function follows the IEEE 754-2008 standard for single-precision 32-bit
+ * floating point numbers, also known as `Float32` (or `binary32`).
+ *
+ * This function is used internally by the {@linkcode fround} function to
+ * convert the input number into a portable intermediate form, which it then
+ * transforms into the `Float32` format via the {@linkcode decodeFloat32}.
+ *
+ * The returned value can be used to store single-precision floating point
+ * values in a DataView via `setUint32`, since it is equivalent to the result
+ * of `DataView.prototype.getUint32` when reading a single-precision float.
+ *
+ * ## Encoding Scheme
+ *
+ * The encoding scheme varies based on the input value classification:
+ *
+ * - Normal (within the normal range of representable values)
+ * - Subnormal (too small to be represented with full precision)
+ * - Special cases (see below)
+ *
+ * ## Special Cases
+ *
+ * The following special cases are handled separately, short-circuiting the
+ * encoding process to return a well-known constant value:
+ *
+ * - `NaN` is encoded as `0x7FC00000` (2139095040).
+ * - `Infinity` is encoded as `0x7F800000` (2139095040).
+ * - `-Infinity` is encoded as `0xFF800000` (4286578688).
+ * - `-0` is encoded as `0x80000000` (2147483648).
+ *
+ * @param value The standard JavaScript number to encode.
+ * @returns An encoded unsigned 32-bit integer that represents the input value.
+ * @example
+ * ```ts
+ * import { encodeFloat32 } from "@nick/math/ieee754";
+ *
+ * console.log(encodeFloat32(3.14)); // 0x40490FDB (1078523339)
+ *
+ * const view = new DataView(new ArrayBuffer(4));
+ * view.setUint32(0, encodeFloat32(3.14));
+ * console.log(view.getUint32(0)); // 1078523339
+ * console.log(view.getFloat32(0)); // 3.140625
+ * ```
+ * @category IEEE-754
+ * @tags float32, encode
+ */
+export declare function encodeFloat32(value: number): number;
+//# sourceMappingURL=encode.d.ts.map

package/esm/float32/encode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.d.ts","sourceRoot":"","sources":["../../src/float32/encode.ts"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAEnD"}

package/esm/float32/encode.js

@@ -0,0 +1,71 @@
+/**
+ * This module provides functions for encoding standard JavaScript numbers
+ * (64-bit double-precision floating point values) into 32-bit unsigned
+ * integers (Uint32) that represent single-precision floating point numbers.
+ *
+ * The `Float32` format is a 32-bit representation of a floating point number
+ * that follows the IEEE 754-2008 standard for single-precision binary32
+ * floating point numbers. This format is used to store floating point values
+ * in a DataView via `setUint32`, and is equivalent to the result of calling
+ * `DataView.prototype.getUint32` when reading a single-precision float.
+ *
+ * To decode a `Float32` value back into a standard JavaScript number, use the
+ * {@linkcode decodeFloat32} function of the `./decode` module, passing it the
+ * encoded value returned by {@linkcode encodeFloat32}.
+ *
+ * @module float32/encode
+ */
+import float32 from "./constants.js";
+import { encode } from "../internal/ieee754.js";
+/**
+ * Encodes a standard JavaScript number (a 64-bit double-precision floating
+ * point value, 52 bits of mantissa) into a 32-bit unsigned integer (Uint32).
+ * This function follows the IEEE 754-2008 standard for single-precision 32-bit
+ * floating point numbers, also known as `Float32` (or `binary32`).
+ *
+ * This function is used internally by the {@linkcode fround} function to
+ * convert the input number into a portable intermediate form, which it then
+ * transforms into the `Float32` format via the {@linkcode decodeFloat32}.
+ *
+ * The returned value can be used to store single-precision floating point
+ * values in a DataView via `setUint32`, since it is equivalent to the result
+ * of `DataView.prototype.getUint32` when reading a single-precision float.
+ *
+ * ## Encoding Scheme
+ *
+ * The encoding scheme varies based on the input value classification:
+ *
+ * - Normal (within the normal range of representable values)
+ * - Subnormal (too small to be represented with full precision)
+ * - Special cases (see below)
+ *
+ * ## Special Cases
+ *
+ * The following special cases are handled separately, short-circuiting the
+ * encoding process to return a well-known constant value:
+ *
+ * - `NaN` is encoded as `0x7FC00000` (2139095040).
+ * - `Infinity` is encoded as `0x7F800000` (2139095040).
+ * - `-Infinity` is encoded as `0xFF800000` (4286578688).
+ * - `-0` is encoded as `0x80000000` (2147483648).
+ *
+ * @param value The standard JavaScript number to encode.
+ * @returns An encoded unsigned 32-bit integer that represents the input value.
+ * @example
+ * ```ts
+ * import { encodeFloat32 } from "@nick/math/ieee754";
+ *
+ * console.log(encodeFloat32(3.14)); // 0x40490FDB (1078523339)
+ *
+ * const view = new DataView(new ArrayBuffer(4));
+ * view.setUint32(0, encodeFloat32(3.14));
+ * console.log(view.getUint32(0)); // 1078523339
+ * console.log(view.getFloat32(0)); // 3.140625
+ * ```
+ * @category IEEE-754
+ * @tags float32, encode
+ */
+export function encodeFloat32(value) {
+    return encode(value, float32);
+}
+//# sourceMappingURL=encode.js.map

package/esm/float32/encode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float32/encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AACH,OAAO,OAAO,MAAM,gBAAgB,CAAC;AACrC,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,MAAM,UAAU,aAAa,CAAC,KAAa;IACzC,OAAO,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;AAChC,CAAC"}

package/esm/float32/guards.d.ts

@@ -0,0 +1,37 @@
+import { type Finite } from "../guards/finite.js";
+import type { Float32 } from "../types/float.js";
+/**
+ * Checks if a value is a valid {@linkcode Float32} as per IEEE 754-2008.
+ *
+ * @param it The value to check.
+ * @returns `true` if the value is a {@linkcode Float32}; otherwise, false.
+ * @see https://en.wikipedia.org/wiki/Single-precision_floating-point_format
+ * @see https://en.wikipedia.org/wiki/IEEE_754
+ * @example
+ * ```ts
+ * import { isFloat32 } from "@nick/math/float32/guards";
+ *
+ * console.log(isFloat32(0.5)); // true
+ * console.log(isFloat32(0.1)); // false
+ * ```
+ * @see {@linkcode isFloat16} for a similar function for float16 numbers.
+ * @category Guards
+ * @tags float32
+ */
+export declare function isFloat32<N extends number>(it: N): it is Float32<N>;
+export declare function isFloat32(it: unknown): it is Float32<number>;
+/**
+ * Checks if the given value is a finite float32 number, as per the IEEE
+ * 754-2008 spec. This is a stricter version of {@linkcode isFloat32} that also
+ * checks if the value is finite, i.e. neither `Infinity`, `-Infinity`, nor
+ * `NaN`.
+ *
+ * @param value The value to check.
+ * @returns `true` if the value is a finite float32 number, `false` otherwise.
+ * @see {@linkcode isFloat32} for a less strict version of this function.
+ * @category Guards
+ * @tags float32
+ */
+export declare function isFiniteFloat32<N extends number>(it: N): it is Finite<N> & Float32<N>;
+export declare function isFiniteFloat32(it: unknown): it is Float32<number>;
+//# sourceMappingURL=guards.d.ts.map

package/esm/float32/guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../src/float32/guards.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,KAAK,MAAM,EAAY,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,mBAAmB,CAAC;AAGjD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,SAAS,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,IAAI,OAAO,CAAC,CAAC,CAAC,CAAC;AACrE,wBAAgB,SAAS,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC;AAK9D;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAAC,CAAC,SAAS,MAAM,EAC9C,EAAE,EAAE,CAAC,GACJ,EAAE,IAAI,MAAM,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAChC,wBAAgB,eAAe,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,OAAO,CAAC,MAAM,CAAC,CAAC"}

package/esm/float32/guards.js

@@ -0,0 +1,16 @@
+/**
+ * This submodule provides type guards specific to the float32 module of the
+ * `@nick/math` library, namely the {@linkcode isFloat32} predicate function.
+ *
+ * @module float32/guards
+ */
+import { isNaN } from "../guards/nan.js";
+import { isFinite } from "../guards/finite.js";
+import { roundFloat32 } from "./round.js";
+export function isFloat32(it) {
+    return typeof it === "number" && !isNaN(it) && it === roundFloat32(it);
+}
+export function isFiniteFloat32(it) {
+    return isFloat32(it) && isFinite(it);
+}
+//# sourceMappingURL=guards.js.map

package/esm/float32/guards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"guards.js","sourceRoot":"","sources":["../../src/float32/guards.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AACzC,OAAO,EAAe,QAAQ,EAAE,MAAM,qBAAqB,CAAC;AAE5D,OAAO,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAsB1C,MAAM,UAAU,SAAS,CAAC,EAAW;IACnC,OAAO,OAAO,EAAE,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,YAAY,CAAC,EAAE,CAAC,CAAC;AACzE,CAAC;AAkBD,MAAM,UAAU,eAAe,CAAC,EAAW;IACzC,OAAO,SAAS,CAAC,EAAE,CAAC,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC;AACvC,CAAC"}