@nberlette/math 0.7.0

package/esm/cosh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosh.js","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;;;GAOG;AACH,MAAM,UAAU,IAAI,CAAC,CAAS;IAC5B,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAChC,CAAC"}

package/esm/exp.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Calculates the exponential function of a number, returning `e^x`.
+ *
+ * This is functionally equivalent to the `Math.exp` function.
+ *
+ * @param x The number to calculate the exponential function of (e^x)
+ * @returns The exponential function of the provided number.
+ * @category Exponential
+ * @example
+ * ```ts no-eval
+ * import { exp } from "@nick/math";
+ * import assert from "node:assert";
+ *
+ * assert.equal(exp(0), 1);
+ * assert.equal(exp(1), 2.7182818284590455);
+ * assert.equal(exp(2), 7.389056098930649);
+ * ```
+ */
+export declare function exp(x: number): number;
+//# sourceMappingURL=exp.d.ts.map

package/esm/exp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exp.d.ts","sourceRoot":"","sources":["../src/exp.ts"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAgBrC"}

package/esm/exp.js

@@ -0,0 +1,45 @@
+/**
+ * @category Exponential
+ * @module exp
+ */
+import { EPSILON } from "./constants/epsilon.js";
+import { isNegativeInfinity } from "./guards/negative_infinity.js";
+import { isPositiveInfinity } from "./guards/positive_infinity.js";
+import { isNaN } from "./guards/nan.js";
+import { abs } from "./abs.js";
+/**
+ * Calculates the exponential function of a number, returning `e^x`.
+ *
+ * This is functionally equivalent to the `Math.exp` function.
+ *
+ * @param x The number to calculate the exponential function of (e^x)
+ * @returns The exponential function of the provided number.
+ * @category Exponential
+ * @example
+ * ```ts no-eval
+ * import { exp } from "@nick/math";
+ * import assert from "node:assert";
+ *
+ * assert.equal(exp(0), 1);
+ * assert.equal(exp(1), 2.7182818284590455);
+ * assert.equal(exp(2), 7.389056098930649);
+ * ```
+ */
+export function exp(x) {
+    if (isNegativeInfinity(x))
+        return 0;
+    if (isPositiveInfinity(x) || isNaN(x))
+        return x;
+    if (x === 0)
+        return 1;
+    const a = abs(x);
+    let result = 1, term = 1, iteration = 1;
+    // Using Taylor series expansion to approximate e^x
+    while (term > EPSILON) {
+        term *= a / iteration;
+        result += term;
+        iteration += 1;
+    }
+    return x < 0 ? 1 / result : result;
+}
+//# sourceMappingURL=exp.js.map

package/esm/exp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exp.js","sourceRoot":"","sources":["../src/exp.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,+BAA+B,CAAC;AACnE,OAAO,EAAE,KAAK,EAAE,MAAM,iBAAiB,CAAC;AACxC,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,GAAG,CAAC,CAAS;IAC3B,IAAI,kBAAkB,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,kBAAkB,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAChD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAEtB,MAAM,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACjB,IAAI,MAAM,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC;IAExC,mDAAmD;IACnD,OAAO,IAAI,GAAG,OAAO,EAAE,CAAC;QACtB,IAAI,IAAI,CAAC,GAAG,SAAS,CAAC;QACtB,MAAM,IAAI,IAAI,CAAC;QACf,SAAS,IAAI,CAAC,CAAC;IACjB,CAAC;IAED,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC;AACrC,CAAC"}

package/esm/expm1.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Calculates `exp(x) - 1` (the exponential of x minus 1).
+ *
+ * Accurate even for very small values of x.
+ *
+ * @param x The number whose exponential minus 1 is to be calculated.
+ * @returns The value of `exp(x) - 1`.
+ * @category Exponential
+ */
+export declare function expm1(x: number): number;
+//# sourceMappingURL=expm1.d.ts.map

package/esm/expm1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expm1.d.ts","sourceRoot":"","sources":["../src/expm1.ts"],"names":[],"mappings":"AAYA;;;;;;;;GAQG;AACH,wBAAgB,KAAK,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CASvC"}

package/esm/expm1.js

@@ -0,0 +1,35 @@
+/**
+ * Calculates the exponential of `x` minus 1 (`exp(x) - 1`) with a high degree
+ * of accuracy, even for very small values of `x`.
+ *
+ * @module expm1
+ */
+import { EPSILON } from "./constants/epsilon.js";
+import { abs } from "./abs.js";
+import { exp } from "./exp.js";
+import { NEGATIVE_INFINITY } from "./constants/negative_infinity.js";
+import { POSITIVE_INFINITY } from "./constants/positive_infinity.js";
+/**
+ * Calculates `exp(x) - 1` (the exponential of x minus 1).
+ *
+ * Accurate even for very small values of x.
+ *
+ * @param x The number whose exponential minus 1 is to be calculated.
+ * @returns The value of `exp(x) - 1`.
+ * @category Exponential
+ */
+export function expm1(x) {
+    // fast paths for common cases
+    if ((x = +x) === 0)
+        return x; // respect -0
+    if (x === POSITIVE_INFINITY)
+        return x;
+    if (x === NEGATIVE_INFINITY)
+        return -1;
+    // for very small values of x, exp(x) - 1 is approximately equal to x
+    if (abs(x) < EPSILON)
+        return x;
+    // for all other values of x, exp(x) - 1 is accurate
+    return exp(x) - 1;
+}
+//# sourceMappingURL=expm1.js.map

package/esm/expm1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expm1.js","sourceRoot":"","sources":["../src/expm1.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AAErE;;;;;;;;GAQG;AACH,MAAM,UAAU,KAAK,CAAC,CAAS;IAC7B,8BAA8B;IAC9B,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC,CAAC,aAAa;IAC3C,IAAI,CAAC,KAAK,iBAAiB;QAAE,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,KAAK,iBAAiB;QAAE,OAAO,CAAC,CAAC,CAAC;IACvC,qEAAqE;IACrE,IAAI,GAAG,CAAC,CAAC,CAAC,GAAG,OAAO;QAAE,OAAO,CAAC,CAAC;IAC/B,oDAAoD;IACpD,OAAO,GAAG,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC"}

package/esm/f16round.d.ts

@@ -0,0 +1,24 @@
+/**
+ * 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 { f16round } from "@nick/math/f16round";
+ * import { PI } from "@nick/math/constants";
+ *
+ * console.assert(f16round(PI) === 3.140625); // OK
+ * ```
+ */
+export declare function f16round(x: number): number;
+//# sourceMappingURL=f16round.d.ts.map

package/esm/f16round.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"f16round.d.ts","sourceRoot":"","sources":["../src/f16round.ts"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAE1C"}

package/esm/f16round.js

@@ -0,0 +1,39 @@
+/**
+ * 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
+ *
+ * @module f16round
+ */
+import { roundFloat16 } from "./float16/round.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 { f16round } from "@nick/math/f16round";
+ * import { PI } from "@nick/math/constants";
+ *
+ * console.assert(f16round(PI) === 3.140625); // OK
+ * ```
+ */
+export function f16round(x) {
+    return roundFloat16(x);
+}
+//# sourceMappingURL=f16round.js.map

package/esm/f16round.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"f16round.js","sourceRoot":"","sources":["../src/f16round.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,QAAQ,CAAC,CAAS;IAChC,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC;AACzB,CAAC"}

package/esm/float16/constants.d.ts

@@ -0,0 +1,97 @@
+/**
+ * This module provides constants used by the encoding/decoding APIs in the
+ * `@nick/math/float16` 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 float16/constants
+ */
+/**
+ * Well-known bit pattern representing `NaN` in the IEEE-754 half-precision (or
+ * "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, NaN
+ */
+export declare const FLOAT16_NAN = 32256;
+/**
+ * Well-known bit pattern representing `+Infinity` (positive infinity) in the
+ * IEEE-754 half-precision (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, Infinity
+ */
+export declare const FLOAT16_POSITIVE_INFINITY = 31744;
+/**
+ * Well-known bit pattern representing `-Infinity` (negative infinity) in the
+ * IEEE-754 half-precision (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, Infinity
+ */
+export declare const FLOAT16_NEGATIVE_INFINITY = 64512;
+/**
+ * Well-known bit pattern representing `-0` (negative zero) in the IEEE-754
+ * half-precision (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, zero
+ */
+export declare const FLOAT16_NEGATIVE_ZERO = 32768;
+/**
+ * Well-known bit pattern representing `+0` (positive zero) in the IEEE-754
+ * half-precision (or "binary16") 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 float16, ieee-754, zero
+ */
+export declare const FLOAT16_POSITIVE_ZERO = 0;
+/**
+ * The number of bits used for the exponent in the IEEE-754 half-precision
+ * (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, exponent
+ */
+export declare const FLOAT16_EXPONENT_BITS = 5;
+/**
+ * The number of bits used for the mantissa in the IEEE-754 half-precision
+ * (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, mantissa
+ */
+export declare const FLOAT16_MANTISSA_BITS = 10;
+/**
+ * The exponent bias used in the IEEE-754 half-precision (or "binary16")
+ * format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, bias
+ */
+export declare const FLOAT16_EXPONENT_BIAS = 15;
+/**
+ * Represents the IEEE-754 binary16 (half-precision) floating-point format.
+ *
+ * @internal
+ */
+declare const _default: {
+    readonly exponent: 5;
+    readonly mantissa: 10;
+    readonly bias: 15;
+    readonly nan: 32256;
+    readonly positive_infinity: 31744;
+    readonly negative_infinity: 64512;
+    readonly negative_zero: 32768;
+    readonly positive_zero: 0;
+};
+export default _default;
+//# sourceMappingURL=constants.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../src/float16/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,QAAS,CAAC;AAElC;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,yBAAyB,QAAS,CAAC;AAEhD;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,QAAS,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB,IAAS,CAAC;AAE5C;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,IAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAM,CAAC;AAEzC;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,KAAM,CAAC;AAEzC;;;;GAIG;;;;;;;;;;;AACH,wBASiC"}

package/esm/float16/constants.js

@@ -0,0 +1,96 @@
+/**
+ * This module provides constants used by the encoding/decoding APIs in the
+ * `@nick/math/float16` 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 float16/constants
+ */
+/**
+ * Well-known bit pattern representing `NaN` in the IEEE-754 half-precision (or
+ * "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, NaN
+ */
+export const FLOAT16_NAN = 0x7E00;
+/**
+ * Well-known bit pattern representing `+Infinity` (positive infinity) in the
+ * IEEE-754 half-precision (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, Infinity
+ */
+export const FLOAT16_POSITIVE_INFINITY = 0x7C00;
+/**
+ * Well-known bit pattern representing `-Infinity` (negative infinity) in the
+ * IEEE-754 half-precision (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, Infinity
+ */
+export const FLOAT16_NEGATIVE_INFINITY = 0xFC00;
+/**
+ * Well-known bit pattern representing `-0` (negative zero) in the IEEE-754
+ * half-precision (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, zero
+ */
+export const FLOAT16_NEGATIVE_ZERO = 0x8000;
+/**
+ * Well-known bit pattern representing `+0` (positive zero) in the IEEE-754
+ * half-precision (or "binary16") 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 float16, ieee-754, zero
+ */
+export const FLOAT16_POSITIVE_ZERO = 0x0000;
+/**
+ * The number of bits used for the exponent in the IEEE-754 half-precision
+ * (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, exponent
+ */
+export const FLOAT16_EXPONENT_BITS = 0x5;
+/**
+ * The number of bits used for the mantissa in the IEEE-754 half-precision
+ * (or "binary16") format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, mantissa
+ */
+export const FLOAT16_MANTISSA_BITS = 0xA;
+/**
+ * The exponent bias used in the IEEE-754 half-precision (or "binary16")
+ * format.
+ *
+ * @category Constants
+ * @tags float16, ieee-754, bias
+ */
+export const FLOAT16_EXPONENT_BIAS = 0xF;
+/**
+ * Represents the IEEE-754 binary16 (half-precision) floating-point format.
+ *
+ * @internal
+ */
+export default {
+    exponent: FLOAT16_EXPONENT_BITS,
+    mantissa: FLOAT16_MANTISSA_BITS,
+    bias: FLOAT16_EXPONENT_BIAS,
+    nan: FLOAT16_NAN,
+    positive_infinity: FLOAT16_POSITIVE_INFINITY,
+    negative_infinity: FLOAT16_NEGATIVE_INFINITY,
+    negative_zero: FLOAT16_NEGATIVE_ZERO,
+    positive_zero: FLOAT16_POSITIVE_ZERO,
+};
+//# sourceMappingURL=constants.js.map

package/esm/float16/constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","sourceRoot":"","sources":["../../src/float16/constants.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,MAAM,CAAC;AAElC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,MAAM,CAAC;AAEhD;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,MAAM,CAAC;AAE5C;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,GAAG,CAAC;AAEzC;;;;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/float16/decode.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Decodes a 16-bit unsigned integer (`Uint16`) into a 16-bit half-precision
+ * floating point value (`Float16`) with 10 bits of mantissa. This function
+ * follows the IEEE 754-2008 spec for half-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 encodeFloat16} function, or by
+ * DataView's `getUint16` method when reading a half-precision float.
+ *
+ * This function is used internally by the {@linkcode f16round} function to
+ * convert the intermediate value back into a standard JavaScript number. The
+ * returned value is a standard JavaScript number, which can be used in
+ * arithmetic operations or passed to other functions.
+ *
+ * ## 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):
+ *
+ * - `0x7E00` (32256) decodes to `NaN`
+ * - `0x7C00` (31744) decodes to `+Infinity`
+ * - `0xFC00` (64512) decodes to `-Infinity`
+ * - `0x8000` (32768) decodes to `-0`
+ *
+ * @param bits The encoded 16-bit half-precision floating point value.
+ * @returns The decoded standard JavaScript number.
+ * @example
+ * ```ts
+ * import { decodeFloat16 } from "@nick/math/float16";
+ *
+ * console.log(decodeFloat16(0x4248)); // 3.140625
+ *
+ * const view = new DataView(new Float16Array([3.14]).buffer);
+ * console.log(decodeFloat16(view.getUint16(0))); // 3.140625
+ * ```
+ * @category IEEE-754
+ * @tags float, float16, decode
+ */
+export declare function decodeFloat16(bits: number): number;
+//# sourceMappingURL=decode.d.ts.map

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

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

package/esm/float16/decode.js

@@ -0,0 +1,61 @@
+/**
+ * This module provides functions for decoding 16-bit half-precision floating
+ * point numbers (`Float16`) from IEEE 754-2008 encoded `Uint16` values, like
+ * those returned by {@linkcode encodeFloat16} or DataView's `geUint16` method.
+ *
+ * The `Float16` format is a 16-bit representation of a floating point number
+ * that follows the IEEE 754-2008 standard for half-precision binary16 floating
+ * point numbers. This format is used to store floating point values in a
+ * DataView or TypedArray, and is used in graphics programming and other
+ * performance-sensitive applications.
+ *
+ * The `decodeFloat16` function decodes a 16-bit half-precision floating point
+ * value into a standard JavaScript number, which can be used in arithmetic
+ * operations or passed to other functions.
+ *
+ * @module float16/decode
+ */
+import float16 from "./constants.js";
+import { decode } from "../internal/ieee754.js";
+/**
+ * Decodes a 16-bit unsigned integer (`Uint16`) into a 16-bit half-precision
+ * floating point value (`Float16`) with 10 bits of mantissa. This function
+ * follows the IEEE 754-2008 spec for half-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 encodeFloat16} function, or by
+ * DataView's `getUint16` method when reading a half-precision float.
+ *
+ * This function is used internally by the {@linkcode f16round} function to
+ * convert the intermediate value back into a standard JavaScript number. The
+ * returned value is a standard JavaScript number, which can be used in
+ * arithmetic operations or passed to other functions.
+ *
+ * ## 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):
+ *
+ * - `0x7E00` (32256) decodes to `NaN`
+ * - `0x7C00` (31744) decodes to `+Infinity`
+ * - `0xFC00` (64512) decodes to `-Infinity`
+ * - `0x8000` (32768) decodes to `-0`
+ *
+ * @param bits The encoded 16-bit half-precision floating point value.
+ * @returns The decoded standard JavaScript number.
+ * @example
+ * ```ts
+ * import { decodeFloat16 } from "@nick/math/float16";
+ *
+ * console.log(decodeFloat16(0x4248)); // 3.140625
+ *
+ * const view = new DataView(new Float16Array([3.14]).buffer);
+ * console.log(decodeFloat16(view.getUint16(0))); // 3.140625
+ * ```
+ * @category IEEE-754
+ * @tags float, float16, decode
+ */
+export function decodeFloat16(bits) {
+    return decode(bits, float16);
+}
+//# sourceMappingURL=decode.js.map

package/esm/float16/decode.js.map

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

package/esm/float16/encode.d.ts

@@ -0,0 +1,67 @@
+/**
+ * This module provides functions for encoding standard JavaScript numbers into
+ * 16-bit half-precision floating point numbers (`Float16`) that follow the
+ * IEEE 754-2008 standard for half-precision binary16 floating point numbers.
+ *
+ * The `Float16` format is a 16-bit representation of a floating point number
+ * that is used to store floating point values in a DataView or TypedArray.
+ * This format is used in graphics programming and other performance-sensitive
+ * applications.
+ *
+ * The `encodeFloat16` function encodes a standard JavaScript number into a
+ * 16-bit half-precision floating point value, which can be stored in a
+ * DataView via `setUint16`, or used in other applications that require the
+ * `Float16` format.
+ *
+ * @module float16/encode
+ */
+/**
+ * Encodes a standard JavaScript number (a 64-bit double-precision floating
+ * point value, 52 bits of mantissa) into a 16-bit unsigned integer (Uint16).
+ * This function follows the IEEE 754-2008 standard for half-precision 16-bit
+ * floating point numbers, also known as `Float16` (or `binary16` in the spec).
+ *
+ * This function is used internally by the {@linkcode f16round} function to
+ * convert the input number into a portable intermediate form, which it then
+ * transforms into the `Float16` format via the {@linkcode decodeFloat16}.
+ *
+ * The returned value can be used to store half-precision floating point values
+ * in a DataView via `setUint16`, since it is equivalent to the result of the
+ * method `DataView.prototype.getUint16` when reading a half-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
+ *
+ * ## 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 `0x7E00` (32256).
+ * - `Infinity` is encoded as `0x7C00` (31744).
+ * - `-Infinity` is encoded as `0xFC00` (64512).
+ * - `-0` is encoded as `0x8000` (32768).
+ *
+ * @param value The standard JavaScript number to encode.
+ * @returns An encoded unsigned 16-bit integer that represents the input value.
+ * @example
+ * ```ts
+ * import { encodeFloat16 } from "@nick/math/float16";
+ *
+ * console.log(encodeFloat16(3.14)); // 0x4248 (16968)
+ *
+ * const view = new DataView(new ArrayBuffer(2));
+ * view.setUint16(0, encodeFloat16(3.14));
+ * console.log(view.getUint16(0)); // 16968
+ * console.log(view.getFloat16(0)); // 3.140625
+ * ```
+ * @category IEEE-754
+ * @tags float16, float, encode
+ */
+export declare function encodeFloat16(value: number): number;
+//# sourceMappingURL=encode.d.ts.map

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

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

package/esm/float16/encode.js

@@ -0,0 +1,71 @@
+/**
+ * This module provides functions for encoding standard JavaScript numbers into
+ * 16-bit half-precision floating point numbers (`Float16`) that follow the
+ * IEEE 754-2008 standard for half-precision binary16 floating point numbers.
+ *
+ * The `Float16` format is a 16-bit representation of a floating point number
+ * that is used to store floating point values in a DataView or TypedArray.
+ * This format is used in graphics programming and other performance-sensitive
+ * applications.
+ *
+ * The `encodeFloat16` function encodes a standard JavaScript number into a
+ * 16-bit half-precision floating point value, which can be stored in a
+ * DataView via `setUint16`, or used in other applications that require the
+ * `Float16` format.
+ *
+ * @module float16/encode
+ */
+import float16 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 16-bit unsigned integer (Uint16).
+ * This function follows the IEEE 754-2008 standard for half-precision 16-bit
+ * floating point numbers, also known as `Float16` (or `binary16` in the spec).
+ *
+ * This function is used internally by the {@linkcode f16round} function to
+ * convert the input number into a portable intermediate form, which it then
+ * transforms into the `Float16` format via the {@linkcode decodeFloat16}.
+ *
+ * The returned value can be used to store half-precision floating point values
+ * in a DataView via `setUint16`, since it is equivalent to the result of the
+ * method `DataView.prototype.getUint16` when reading a half-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
+ *
+ * ## 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 `0x7E00` (32256).
+ * - `Infinity` is encoded as `0x7C00` (31744).
+ * - `-Infinity` is encoded as `0xFC00` (64512).
+ * - `-0` is encoded as `0x8000` (32768).
+ *
+ * @param value The standard JavaScript number to encode.
+ * @returns An encoded unsigned 16-bit integer that represents the input value.
+ * @example
+ * ```ts
+ * import { encodeFloat16 } from "@nick/math/float16";
+ *
+ * console.log(encodeFloat16(3.14)); // 0x4248 (16968)
+ *
+ * const view = new DataView(new ArrayBuffer(2));
+ * view.setUint16(0, encodeFloat16(3.14));
+ * console.log(view.getUint16(0)); // 16968
+ * console.log(view.getFloat16(0)); // 3.140625
+ * ```
+ * @category IEEE-754
+ * @tags float16, float, encode
+ */
+export function encodeFloat16(value) {
+    return encode(value, float16);
+}
+//# sourceMappingURL=encode.js.map

package/esm/float16/encode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode.js","sourceRoot":"","sources":["../../src/float16/encode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,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"}