@nberlette/math 0.7.0

package/cjs/constants/nan.js

@@ -0,0 +1,30 @@
+"use strict";
+/**
+ * Not a Number (`NaN`) is a special value representing all values which are
+ * not valid numbers. It is approximately equal to `0 / 0`, meaning it is a
+ * non-representable, non-finite, non-zero result of an invalid math operation.
+ *
+ * `NaN` is the only value in JavaScript which is not less than, greater than,
+ * nor equal to any other value, including itself. It is the result of invalid
+ * mathematical operations, such as dividing zero by zero, or parsing a string
+ * that does not represent a valid number with `parseInt` or `parseFloat`.
+ *
+ * @module nan
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NaN = exports.NAN = void 0;
+// purposely kept private and local to this module only, preventing external
+// code from imitating the `NaN` type below.
+const Not_a_Number = Symbol("Is_NaN");
+/**
+ * Represents the special value "Not a Number" (`NaN`), which is used to denote
+ * an invalid number. It is approximately equivalent to `0 / 0`.
+ *
+ * This is a local implementation of the native `Number.NaN` constant.
+ *
+ * @category Constants
+ * @tags Number, NaN
+ */
+exports.NAN = 0 / 0;
+exports.NaN = exports.NAN;
+//# sourceMappingURL=nan.js.map

package/cjs/constants/nan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nan.js","sourceRoot":"","sources":["../../src/constants/nan.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;GAWG;;;AAEH,4EAA4E;AAC5E,4CAA4C;AAC5C,MAAM,YAAY,GAAkB,MAAM,CAAC,QAAQ,CAAC,CAAC;AAwBrD;;;;;;;;GAQG;AACU,QAAA,GAAG,GAAQ,CAAC,GAAG,CAAQ,CAAC;AAQrB,cARH,WAAG,CAQG"}

package/cjs/constants/negative_infinity.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Negative Infinity is a special value representing negative infinity, which
+ * is less than any other number. It is approximately equal to
+ * `-1.7976931348623159e+308`.
+ *
+ * This is a local implementation of the native `Number.NEGATIVE_INFINITY`
+ * constant.
+ * @category Constants
+ * @tags Infinity
+ */
+export declare const NEGATIVE_INFINITY: NEGATIVE_INFINITY;
+/**
+ * Special type used to represent `-Infinity` (negative infinity). TypeScript's
+ * built-in types do not distinguish between positive/negative infinity and any
+ * other `number`. However, its type checker _is_ capable of differentiating
+ * between those types and other literal numbers.
+ *
+ * This type simply (ab)uses the type system's handling of scientific notation:
+ * by using an arbitrary exponent in excess of `308`, the type checker can now
+ * recognize and represent the type as `Infinity`. Great success!
+ *
+ * NB: Credit to Sindre Sorhus and his type-fest project for this approach.
+ *
+ * @category Types
+ * @tags Infinity
+ */
+export type NEGATIVE_INFINITY = -1e333;
+//# sourceMappingURL=negative_infinity.d.ts.map

package/cjs/constants/negative_infinity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative_infinity.d.ts","sourceRoot":"","sources":["../../src/constants/negative_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAA+C,CAAC;AAEhF;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,KAAK,CAAC"}

package/cjs/constants/negative_infinity.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEGATIVE_INFINITY = void 0;
+/**
+ * Negative Infinity is a special value representing negative infinity, which
+ * is less than any other number. It is approximately equal to
+ * `-1.7976931348623159e+308`.
+ *
+ * This is a local implementation of the native `Number.NEGATIVE_INFINITY`
+ * constant.
+ * @category Constants
+ * @tags Infinity
+ */
+exports.NEGATIVE_INFINITY = -1 / 0;
+//# sourceMappingURL=negative_infinity.js.map

package/cjs/constants/negative_infinity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative_infinity.js","sourceRoot":"","sources":["../../src/constants/negative_infinity.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACU,QAAA,iBAAiB,GAAsB,CAAC,CAAC,GAAG,CAAsB,CAAC"}

package/cjs/constants/negative_zero.d.ts

@@ -0,0 +1,31 @@
+/**
+ * This module provides a constant value and a branded nominal type for the
+ * special number negative zero (`-0`). This is a non-standard extension of the
+ * native JavaScript language, provided for stronger type-safety when working
+ * with negative zero values.
+ *
+ * @module negative-zero
+ */
+declare const NegativeZero: unique symbol;
+interface NegativeZero {
+    readonly [NegativeZero]: never;
+}
+/**
+ * Represents the special number negative zero (`-0`).
+ *
+ * @category Constants
+ * @tags Negative Zero
+ */
+export declare const NEGATIVE_ZERO: NEGATIVE_ZERO;
+/**
+ * @remarks
+ * TypeScript is not capable of distinguishing `-0` from `0` on a type level.
+ * This type helps fill that gap by providing a branded nominal type for it,
+ * allowing you to perform strict type checking and narrowing against negative
+ * zero values.
+ *
+ * @see {@linkcode isNegativeZero} to check runtime values against this type.
+ */
+export type NEGATIVE_ZERO = -0 & NegativeZero;
+export {};
+//# sourceMappingURL=negative_zero.d.ts.map

package/cjs/constants/negative_zero.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative_zero.d.ts","sourceRoot":"","sources":["../../src/constants/negative_zero.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,QAAA,MAAM,YAAY,EAAE,OAAO,MAAqB,CAAC;AAEjD,UAAU,YAAY;IACpB,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC;AAED;;;;;GAKG;AACH,eAAO,MAAM,aAAa,EAAE,aAAmC,CAAC;AAEhE;;;;;;;;GAQG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,GAAG,YAAY,CAAC"}

package/cjs/constants/negative_zero.js

@@ -0,0 +1,21 @@
+"use strict";
+/**
+ * This module provides a constant value and a branded nominal type for the
+ * special number negative zero (`-0`). This is a non-standard extension of the
+ * native JavaScript language, provided for stronger type-safety when working
+ * with negative zero values.
+ *
+ * @module negative-zero
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NEGATIVE_ZERO = void 0;
+// deno-lint-ignore no-unused-vars
+const NegativeZero = Symbol("-0");
+/**
+ * Represents the special number negative zero (`-0`).
+ *
+ * @category Constants
+ * @tags Negative Zero
+ */
+exports.NEGATIVE_ZERO = -0;
+//# sourceMappingURL=negative_zero.js.map

package/cjs/constants/negative_zero.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"negative_zero.js","sourceRoot":"","sources":["../../src/constants/negative_zero.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAEH,kCAAkC;AAClC,MAAM,YAAY,GAAkB,MAAM,CAAC,IAAI,CAAC,CAAC;AAMjD;;;;;GAKG;AACU,QAAA,aAAa,GAAkB,CAAC,CAAkB,CAAC"}

package/cjs/constants/pi.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Represents the mathematical constant `π` (pi), the ratio of a circle's
+ * circumference to its diameter, approximately equal to `3.141592653589793`.
+ *
+ * This is a local implementation of the native `Math.PI` constant.
+ * @category Constants
+ */
+export declare const PI: PI;
+export type PI = 3.141592653589793;
+//# sourceMappingURL=pi.d.ts.map

package/cjs/constants/pi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi.d.ts","sourceRoot":"","sources":["../../src/constants/pi.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,EAAE,EAAE,EAAsB,CAAC;AACxC,MAAM,MAAM,EAAE,GAAG,iBAAiB,CAAC"}

package/cjs/constants/pi.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PI = void 0;
+/**
+ * Represents the mathematical constant `π` (pi), the ratio of a circle's
+ * circumference to its diameter, approximately equal to `3.141592653589793`.
+ *
+ * This is a local implementation of the native `Math.PI` constant.
+ * @category Constants
+ */
+exports.PI = 3.141592653589793;
+//# sourceMappingURL=pi.js.map

package/cjs/constants/pi.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pi.js","sourceRoot":"","sources":["../../src/constants/pi.ts"],"names":[],"mappings":";;;AAAA;;;;;;GAMG;AACU,QAAA,EAAE,GAAO,iBAAiB,CAAC"}

package/cjs/constants/positive_infinity.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Positive Infinity is a special value representing positive infinity, which
+ * is greater than any other number. It is approximately equal to
+ * `1.7976931348623159e+308`.
+ *
+ * This is a local implementation of the native `Number.POSITIVE_INFINITY`
+ * constant.
+ * @category Constants
+ * @tags Infinity
+ */
+export declare const POSITIVE_INFINITY: POSITIVE_INFINITY;
+/**
+ * Special type used to represent `+Infinity` (positive infinity). TypeScript's
+ * built-in types do not distinguish between positive/negative infinity and any
+ * other `number`. However, its type checker _is_ capable of differentiating
+ * between those types and other literal numbers.
+ *
+ * This type simply (ab)uses the type system's handling of scientific notation:
+ * by using an arbitrary exponent in excess of `308`, the type checker can now
+ * recognize and represent the type as `Infinity`. Great success!
+ *
+ * NB: Credit to Sindre Sorhus and his type-fest project for this approach.
+ *
+ * @category Types
+ * @tags Infinity
+ */
+export type POSITIVE_INFINITY = 1e333;
+export { POSITIVE_INFINITY as Infinity };
+//# sourceMappingURL=positive_infinity.d.ts.map

package/cjs/constants/positive_infinity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positive_infinity.d.ts","sourceRoot":"","sources":["../../src/constants/positive_infinity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,EAAE,iBAA8C,CAAC;AAE/E;;;;;;;;;;;;;;GAcG;AACH,MAAM,MAAM,iBAAiB,GAAG,KAAK,CAAC;AAEtC,OAAO,EAAE,iBAAiB,IAAI,QAAQ,EAAE,CAAC"}

package/cjs/constants/positive_infinity.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Infinity = exports.POSITIVE_INFINITY = void 0;
+/**
+ * Positive Infinity is a special value representing positive infinity, which
+ * is greater than any other number. It is approximately equal to
+ * `1.7976931348623159e+308`.
+ *
+ * This is a local implementation of the native `Number.POSITIVE_INFINITY`
+ * constant.
+ * @category Constants
+ * @tags Infinity
+ */
+exports.POSITIVE_INFINITY = 1 / 0;
+exports.Infinity = exports.POSITIVE_INFINITY;
+//# sourceMappingURL=positive_infinity.js.map

package/cjs/constants/positive_infinity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"positive_infinity.js","sourceRoot":"","sources":["../../src/constants/positive_infinity.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;GASG;AACU,QAAA,iBAAiB,GAAsB,CAAC,GAAG,CAAsB,CAAC;AAmBjD,mBAnBjB,yBAAiB,CAmBQ"}

package/cjs/constants/positive_zero.d.ts

@@ -0,0 +1,38 @@
+/**
+ * This module provides a constant value and a branded nominal type for the
+ * special number positive zero (`-0`). This is a non-standard extension of the
+ * native JavaScript language, provided for stronger type-safety when working
+ * with positive zero values.
+ *
+ * @module positive-zero
+ */
+declare const PositiveZero: unique symbol;
+interface PositiveZero {
+    readonly [PositiveZero]: never;
+}
+/**
+ * Represents a value that has been verified at runtime to be positive zero,
+ * (i.e. exactly `0`, and not `-0`).
+ *
+ * This is provided as both a constant runtime value and as a branded nominal
+ * type alias for `0`, for use in type-level checks and narrowing where you
+ * need a higher level of type-safety than just a standard literal `0`.
+ *
+ * @category Constants
+ * @tags Positive Zero
+ * @example
+ * ```ts
+ * import { POSITIVE_ZERO } from "@nick/math/constants/positive-zero";
+ * import { isPositiveZero } from "@nick/math/is/positive-zero";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(isPositiveZero(-0), false); // OK
+ * assert.strictEqual(isPositiveZero(POSITIVE_ZERO), true); // OK
+ * assert.strictEqual(POSITIVE_ZERO, 0); // OK
+ * ```
+ */
+export declare const POSITIVE_ZERO: POSITIVE_ZERO;
+/** @inheritdoc */
+export type POSITIVE_ZERO = 0 & PositiveZero;
+export {};
+//# sourceMappingURL=positive_zero.d.ts.map

package/cjs/constants/positive_zero.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"positive_zero.d.ts","sourceRoot":"","sources":["../../src/constants/positive_zero.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,QAAA,MAAM,YAAY,EAAE,OAAO,MAAoB,CAAC;AAEhD,UAAU,YAAY;IACpB,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,aAAa,EAAE,aAAkC,CAAC;AAE/D,kBAAkB;AAClB,MAAM,MAAM,aAAa,GAAG,CAAC,GAAG,YAAY,CAAC"}

package/cjs/constants/positive_zero.js

@@ -0,0 +1,36 @@
+"use strict";
+/**
+ * This module provides a constant value and a branded nominal type for the
+ * special number positive zero (`-0`). This is a non-standard extension of the
+ * native JavaScript language, provided for stronger type-safety when working
+ * with positive zero values.
+ *
+ * @module positive-zero
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.POSITIVE_ZERO = void 0;
+// deno-lint-ignore no-unused-vars
+const PositiveZero = Symbol("0");
+/**
+ * Represents a value that has been verified at runtime to be positive zero,
+ * (i.e. exactly `0`, and not `-0`).
+ *
+ * This is provided as both a constant runtime value and as a branded nominal
+ * type alias for `0`, for use in type-level checks and narrowing where you
+ * need a higher level of type-safety than just a standard literal `0`.
+ *
+ * @category Constants
+ * @tags Positive Zero
+ * @example
+ * ```ts
+ * import { POSITIVE_ZERO } from "@nick/math/constants/positive-zero";
+ * import { isPositiveZero } from "@nick/math/is/positive-zero";
+ * import assert from "node:assert";
+ *
+ * assert.strictEqual(isPositiveZero(-0), false); // OK
+ * assert.strictEqual(isPositiveZero(POSITIVE_ZERO), true); // OK
+ * assert.strictEqual(POSITIVE_ZERO, 0); // OK
+ * ```
+ */
+exports.POSITIVE_ZERO = 0;
+//# sourceMappingURL=positive_zero.js.map

package/cjs/constants/positive_zero.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"positive_zero.js","sourceRoot":"","sources":["../../src/constants/positive_zero.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAEH,kCAAkC;AAClC,MAAM,YAAY,GAAkB,MAAM,CAAC,GAAG,CAAC,CAAC;AAMhD;;;;;;;;;;;;;;;;;;;;GAoBG;AACU,QAAA,aAAa,GAAkB,CAAkB,CAAC"}

package/cjs/constants/sqrt1_2.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The square root of `1/2`, approximately equal to `0.7071067811865476`.
+ *
+ * This is a local implementation of the native `Math.SQRT1_2` constant.
+ * @category Constants
+ */
+export declare const SQRT1_2: SQRT1_2;
+export type SQRT1_2 = 0.7071067811865476;
+//# sourceMappingURL=sqrt1_2.d.ts.map

package/cjs/constants/sqrt1_2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrt1_2.d.ts","sourceRoot":"","sources":["../../src/constants/sqrt1_2.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,OAAO,EAAE,OAA4B,CAAC;AACnD,MAAM,MAAM,OAAO,GAAG,kBAAkB,CAAC"}

package/cjs/constants/sqrt1_2.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQRT1_2 = void 0;
+/**
+ * The square root of `1/2`, approximately equal to `0.7071067811865476`.
+ *
+ * This is a local implementation of the native `Math.SQRT1_2` constant.
+ * @category Constants
+ */
+exports.SQRT1_2 = 0.7071067811865476;
+//# sourceMappingURL=sqrt1_2.js.map

package/cjs/constants/sqrt1_2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrt1_2.js","sourceRoot":"","sources":["../../src/constants/sqrt1_2.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,OAAO,GAAY,kBAAkB,CAAC"}

package/cjs/constants/sqrt2.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The square root of `2`, approximately equal to `1.4142135623730951`.
+ *
+ * This is a local implementation of the native `Math.SQRT2` constant.
+ * @category Constants
+ */
+export declare const SQRT2: SQRT2;
+export type SQRT2 = 1.4142135623730951;
+//# sourceMappingURL=sqrt2.d.ts.map

package/cjs/constants/sqrt2.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrt2.d.ts","sourceRoot":"","sources":["../../src/constants/sqrt2.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,eAAO,MAAM,KAAK,EAAE,KAA0B,CAAC;AAC/C,MAAM,MAAM,KAAK,GAAG,kBAAkB,CAAC"}

package/cjs/constants/sqrt2.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQRT2 = void 0;
+/**
+ * The square root of `2`, approximately equal to `1.4142135623730951`.
+ *
+ * This is a local implementation of the native `Math.SQRT2` constant.
+ * @category Constants
+ */
+exports.SQRT2 = 1.4142135623730951;
+//# sourceMappingURL=sqrt2.js.map

package/cjs/constants/sqrt2.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqrt2.js","sourceRoot":"","sources":["../../src/constants/sqrt2.ts"],"names":[],"mappings":";;;AAAA;;;;;GAKG;AACU,QAAA,KAAK,GAAU,kBAAkB,CAAC"}

package/cjs/cos.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculates the cosine of a number, returning a value in the range `[-1, 1]`.
+ *
+ * @param x The angle in radians whose cosine is to be calculated.
+ * @returns The cosine of the provided angle.
+ * @category Trigonometry
+ * @tags cosine
+ */
+export declare function cos(x: number): number;
+//# sourceMappingURL=cos.d.ts.map

package/cjs/cos.d.ts.map

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

package/cjs/cos.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cos = cos;
+/**
+ * Calculates the cosine of a number, returning a value in the range `[-1, 1]`.
+ *
+ * @module cos
+ */
+const abs_js_1 = require("./abs.js");
+const epsilon_js_1 = require("./constants/epsilon.js");
+const nan_js_1 = require("./constants/nan.js");
+const finite_js_1 = require("./guards/finite.js");
+/**
+ * Calculates the cosine of a number, returning a value in the range `[-1, 1]`.
+ *
+ * @param x The angle in radians whose cosine is to be calculated.
+ * @returns The cosine of the provided angle.
+ * @category Trigonometry
+ * @tags cosine
+ */
+function cos(x) {
+    if (!(0, finite_js_1.isFinite)(x))
+        return nan_js_1.NAN;
+    let sum = 1, term = 1, n = 0;
+    while ((0, abs_js_1.abs)(term) > epsilon_js_1.EPSILON) {
+        n += 2;
+        term *= -x * x / (n * (n - 1));
+        sum += term;
+    }
+    return sum;
+}
+//# sourceMappingURL=cos.js.map

package/cjs/cos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cos.js","sourceRoot":"","sources":["../src/cos.ts"],"names":[],"mappings":";;AAkBA,kBAUC;AA5BD;;;;GAIG;AACH,qCAA+B;AAC/B,uDAAiD;AACjD,+CAAyC;AACzC,kDAA8C;AAE9C;;;;;;;GAOG;AACH,SAAgB,GAAG,CAAC,CAAS;IAC3B,IAAI,CAAC,IAAA,oBAAQ,EAAC,CAAC,CAAC;QAAE,OAAO,YAAG,CAAC;IAE7B,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC7B,OAAO,IAAA,YAAG,EAAC,IAAI,CAAC,GAAG,oBAAO,EAAE,CAAC;QAC3B,CAAC,IAAI,CAAC,CAAC;QACP,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;QAC/B,GAAG,IAAI,IAAI,CAAC;IACd,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}

package/cjs/cosh.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Calculates the hyperbolic cosine of a number.
+ *
+ * @param x The number whose hyperbolic cosine is to be calculated.
+ * @returns The hyperbolic cosine of the provided number.
+ * @category Trigonometry
+ * @tags hyperbolic, cosine
+ */
+export declare function cosh(x: number): number;
+//# sourceMappingURL=cosh.d.ts.map

package/cjs/cosh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosh.d.ts","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,wBAAgB,IAAI,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAEtC"}

package/cjs/cosh.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cosh = cosh;
+/**
+ * Calculates the hyperbolic cosine of a number.
+ *
+ * @module cosh
+ */
+const exp_js_1 = require("./exp.js");
+/**
+ * Calculates the hyperbolic cosine of a number.
+ *
+ * @param x The number whose hyperbolic cosine is to be calculated.
+ * @returns The hyperbolic cosine of the provided number.
+ * @category Trigonometry
+ * @tags hyperbolic, cosine
+ */
+function cosh(x) {
+    return ((0, exp_js_1.exp)(x) + (0, exp_js_1.exp)(-x)) / 2;
+}
+//# sourceMappingURL=cosh.js.map

package/cjs/cosh.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cosh.js","sourceRoot":"","sources":["../src/cosh.ts"],"names":[],"mappings":";;AAeA,oBAEC;AAjBD;;;;GAIG;AACH,qCAA+B;AAE/B;;;;;;;GAOG;AACH,SAAgB,IAAI,CAAC,CAAS;IAC5B,OAAO,CAAC,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,IAAA,YAAG,EAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AAChC,CAAC"}

package/cjs/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/cjs/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/cjs/exp.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.exp = exp;
+/**
+ * @category Exponential
+ * @module exp
+ */
+const epsilon_js_1 = require("./constants/epsilon.js");
+const negative_infinity_js_1 = require("./guards/negative_infinity.js");
+const positive_infinity_js_1 = require("./guards/positive_infinity.js");
+const nan_js_1 = require("./guards/nan.js");
+const abs_js_1 = require("./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);
+ * ```
+ */
+function exp(x) {
+    if ((0, negative_infinity_js_1.isNegativeInfinity)(x))
+        return 0;
+    if ((0, positive_infinity_js_1.isPositiveInfinity)(x) || (0, nan_js_1.isNaN)(x))
+        return x;
+    if (x === 0)
+        return 1;
+    const a = (0, abs_js_1.abs)(x);
+    let result = 1, term = 1, iteration = 1;
+    // Using Taylor series expansion to approximate e^x
+    while (term > epsilon_js_1.EPSILON) {
+        term *= a / iteration;
+        result += term;
+        iteration += 1;
+    }
+    return x < 0 ? 1 / result : result;
+}
+//# sourceMappingURL=exp.js.map

package/cjs/exp.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"exp.js","sourceRoot":"","sources":["../src/exp.ts"],"names":[],"mappings":";;AA4BA,kBAgBC;AA5CD;;;GAGG;AACH,uDAAiD;AACjD,wEAAmE;AACnE,wEAAmE;AACnE,4CAAwC;AACxC,qCAA+B;AAE/B;;;;;;;;;;;;;;;;;GAiBG;AACH,SAAgB,GAAG,CAAC,CAAS;IAC3B,IAAI,IAAA,yCAAkB,EAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IACpC,IAAI,IAAA,yCAAkB,EAAC,CAAC,CAAC,IAAI,IAAA,cAAK,EAAC,CAAC,CAAC;QAAE,OAAO,CAAC,CAAC;IAChD,IAAI,CAAC,KAAK,CAAC;QAAE,OAAO,CAAC,CAAC;IAEtB,MAAM,CAAC,GAAG,IAAA,YAAG,EAAC,CAAC,CAAC,CAAC;IACjB,IAAI,MAAM,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,SAAS,GAAG,CAAC,CAAC;IAExC,mDAAmD;IACnD,OAAO,IAAI,GAAG,oBAAO,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/cjs/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/cjs/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/cjs/expm1.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expm1 = expm1;
+/**
+ * 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
+ */
+const epsilon_js_1 = require("./constants/epsilon.js");
+const abs_js_1 = require("./abs.js");
+const exp_js_1 = require("./exp.js");
+const negative_infinity_js_1 = require("./constants/negative_infinity.js");
+const positive_infinity_js_1 = require("./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
+ */
+function expm1(x) {
+    // fast paths for common cases
+    if ((x = +x) === 0)
+        return x; // respect -0
+    if (x === positive_infinity_js_1.POSITIVE_INFINITY)
+        return x;
+    if (x === negative_infinity_js_1.NEGATIVE_INFINITY)
+        return -1;
+    // for very small values of x, exp(x) - 1 is approximately equal to x
+    if ((0, abs_js_1.abs)(x) < epsilon_js_1.EPSILON)
+        return x;
+    // for all other values of x, exp(x) - 1 is accurate
+    return (0, exp_js_1.exp)(x) - 1;
+}
+//# sourceMappingURL=expm1.js.map

package/cjs/expm1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expm1.js","sourceRoot":"","sources":["../src/expm1.ts"],"names":[],"mappings":";;AAqBA,sBASC;AA9BD;;;;;GAKG;AACH,uDAAiD;AACjD,qCAA+B;AAC/B,qCAA+B;AAC/B,2EAAqE;AACrE,2EAAqE;AAErE;;;;;;;;GAQG;AACH,SAAgB,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,wCAAiB;QAAE,OAAO,CAAC,CAAC;IACtC,IAAI,CAAC,KAAK,wCAAiB;QAAE,OAAO,CAAC,CAAC,CAAC;IACvC,qEAAqE;IACrE,IAAI,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,oBAAO;QAAE,OAAO,CAAC,CAAC;IAC/B,oDAAoD;IACpD,OAAO,IAAA,YAAG,EAAC,CAAC,CAAC,GAAG,CAAC,CAAC;AACpB,CAAC"}

package/cjs/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/cjs/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"}