@nberlette/math 0.7.0

package/esm/constants/log2e.js

@@ -0,0 +1,9 @@
+/**
+ * Represents the base-2 logarithm of `e` (Euler's number), approximately equal
+ * to `1.4426950408889634`.
+ *
+ * This is a local implementation of the native `Math.LOG2E` constant.
+ * @category Constants
+ */
+export const LOG2E = 1.4426950408889634;
+//# sourceMappingURL=log2e.js.map

package/esm/constants/log2e.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"log2e.js","sourceRoot":"","sources":["../../src/constants/log2e.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,KAAK,GAAU,kBAAkB,CAAC"}

package/esm/constants/max_safe_integer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Represents the largest integer that can be represented in JavaScript without
+ * losing precision, which is approximately equal to `9007199254740991`.
+ *
+ * This is a local implementation of the native `Number.MAX_SAFE_INTEGER`
+ * constant.
+ * @category Constants
+ */
+export declare const MAX_SAFE_INTEGER: MAX_SAFE_INTEGER;
+export type MAX_SAFE_INTEGER = 9007199254740991;
+//# sourceMappingURL=max_safe_integer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"max_safe_integer.d.ts","sourceRoot":"","sources":["../../src/constants/max_safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAAmC,CAAC;AACnE,MAAM,MAAM,gBAAgB,GAAG,gBAAgB,CAAC"}

package/esm/constants/max_safe_integer.js

@@ -0,0 +1,10 @@
+/**
+ * Represents the largest integer that can be represented in JavaScript without
+ * losing precision, which is approximately equal to `9007199254740991`.
+ *
+ * This is a local implementation of the native `Number.MAX_SAFE_INTEGER`
+ * constant.
+ * @category Constants
+ */
+export const MAX_SAFE_INTEGER = 9007199254740991;
+//# sourceMappingURL=max_safe_integer.js.map

package/esm/constants/max_safe_integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"max_safe_integer.js","sourceRoot":"","sources":["../../src/constants/max_safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAqB,gBAAgB,CAAC"}

package/esm/constants/max_value.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Represents the largest positive finite number that can be represented in
+ * JavaScript, which is approximately equal to `1.7976931348623157e+308`.
+ *
+ * This is a local implementation of the native `Number.MAX_VALUE` constant.
+ * @category Constants
+ */
+export declare const MAX_VALUE: MAX_VALUE;
+export type MAX_VALUE = 1.7976931348623157e308;
+//# sourceMappingURL=max_value.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"max_value.d.ts","sourceRoot":"","sources":["../../src/constants/max_value.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,eAAO,MAAM,SAAS,EAAE,SAAkC,CAAC;AAC3D,MAAM,MAAM,SAAS,GAAG,sBAAsB,CAAC"}

package/esm/constants/max_value.js

@@ -0,0 +1,9 @@
+/**
+ * Represents the largest positive finite number that can be represented in
+ * JavaScript, which is approximately equal to `1.7976931348623157e+308`.
+ *
+ * This is a local implementation of the native `Number.MAX_VALUE` constant.
+ * @category Constants
+ */
+export const MAX_VALUE = 1.7976931348623157e308;
+//# sourceMappingURL=max_value.js.map

package/esm/constants/max_value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"max_value.js","sourceRoot":"","sources":["../../src/constants/max_value.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAc,sBAAsB,CAAC"}

package/esm/constants/min_safe_integer.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Represents the smallest integer that can be represented in JavaScript
+ * without losing precision, which is approximately equal to
+ * `-9007199254740991`.
+ *
+ * This is a local implementation of the native `Number.MIN_SAFE_INTEGER`
+ * constant.
+ * @category Constants
+ */
+export declare const MIN_SAFE_INTEGER: MIN_SAFE_INTEGER;
+export type MIN_SAFE_INTEGER = -9007199254740991;
+//# sourceMappingURL=min_safe_integer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"min_safe_integer.d.ts","sourceRoot":"","sources":["../../src/constants/min_safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,EAAE,gBAAoC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,gBAAgB,CAAC"}

package/esm/constants/min_safe_integer.js

@@ -0,0 +1,11 @@
+/**
+ * Represents the smallest integer that can be represented in JavaScript
+ * without losing precision, which is approximately equal to
+ * `-9007199254740991`.
+ *
+ * This is a local implementation of the native `Number.MIN_SAFE_INTEGER`
+ * constant.
+ * @category Constants
+ */
+export const MIN_SAFE_INTEGER = -9007199254740991;
+//# sourceMappingURL=min_safe_integer.js.map

package/esm/constants/min_safe_integer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"min_safe_integer.js","sourceRoot":"","sources":["../../src/constants/min_safe_integer.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAqB,CAAC,gBAAgB,CAAC"}

package/esm/constants/min_value.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Represents the smallest positive number that is greater than zero, which is
+ * approximately equal to `5e-324`.
+ *
+ * This is a local implementation of the native `Number.MIN_VALUE` constant.
+ * @category Constants
+ */
+export declare const MIN_VALUE: MIN_VALUE;
+export type MIN_VALUE = 5e-324;
+//# sourceMappingURL=min_value.d.ts.map

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

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

package/esm/constants/min_value.js

@@ -0,0 +1,9 @@
+/**
+ * Represents the smallest positive number that is greater than zero, which is
+ * approximately equal to `5e-324`.
+ *
+ * This is a local implementation of the native `Number.MIN_VALUE` constant.
+ * @category Constants
+ */
+export const MIN_VALUE = 5e-324;
+//# sourceMappingURL=min_value.js.map

package/esm/constants/min_value.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"min_value.js","sourceRoot":"","sources":["../../src/constants/min_value.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAc,MAAM,CAAC"}

package/esm/constants/nan.d.ts

@@ -0,0 +1,47 @@
+/**
+ * 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
+ */
+declare const Not_a_Number: unique symbol;
+type Not_a_Number = typeof Not_a_Number;
+/**
+ * Special nominal type representing the "Not a Number" (`NaN`) value. This is
+ * used to distinguish between `NaN` and other `number` values on a type-only
+ * level, allowing you to perform type narrowing and checking for `NaN` values
+ * in a type-safe manner.
+ *
+ * This is the internal unforgeable brand that is used to create the `NAN` type
+ * exported from this module. It is purposely kept private and local to this
+ * module only, to prevent any imitation or manipulation from external code.
+ *
+ * @internal
+ * @private
+ */
+interface NaN {
+    readonly [Not_a_Number]: never;
+}
+/**
+ * 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
+ */
+export declare const NAN: NAN;
+/**
+ * Currently, TypeScript does not provide a built-in solution to distinguish
+ * `NaN` from other non-literal `number` value. This type helps fill that gap.
+ */
+export type NAN = number & NaN;
+export { NAN as NaN };
+//# sourceMappingURL=nan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nan.d.ts","sourceRoot":"","sources":["../../src/constants/nan.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAIH,QAAA,MAAM,YAAY,EAAE,OAAO,MAAyB,CAAC;AACrD,KAAK,YAAY,GAAG,OAAO,YAAY,CAAC;AAExC;;;;;;;;;;;;GAYG;AAKH,UAAU,GAAG;IACX,QAAQ,CAAC,CAAC,YAAY,CAAC,EAAE,KAAK,CAAC;CAChC;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,GAAG,EAAE,GAAkB,CAAC;AAErC;;;GAGG;AACH,MAAM,MAAM,GAAG,GAAG,MAAM,GAAG,GAAG,CAAC;AAE/B,OAAO,EAAE,GAAG,IAAI,GAAG,EAAE,CAAC"}

package/esm/constants/nan.js

@@ -0,0 +1,27 @@
+/**
+ * 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
+ */
+// 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
+ */
+export const NAN = 0 / 0;
+export { NAN as NaN };
+//# sourceMappingURL=nan.js.map

package/esm/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;AACH,MAAM,CAAC,MAAM,GAAG,GAAQ,CAAC,GAAG,CAAQ,CAAC;AAQrC,OAAO,EAAE,GAAG,IAAI,GAAG,EAAE,CAAC"}

package/esm/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/esm/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/esm/constants/negative_infinity.js

@@ -0,0 +1,12 @@
+/**
+ * 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 const NEGATIVE_INFINITY = -1 / 0;
+//# sourceMappingURL=negative_infinity.js.map

package/esm/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;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAsB,CAAC,CAAC,GAAG,CAAsB,CAAC"}

package/esm/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/esm/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/esm/constants/negative_zero.js

@@ -0,0 +1,18 @@
+/**
+ * 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
+ */
+// deno-lint-ignore no-unused-vars
+const NegativeZero = Symbol("-0");
+/**
+ * Represents the special number negative zero (`-0`).
+ *
+ * @category Constants
+ * @tags Negative Zero
+ */
+export const NEGATIVE_ZERO = -0;
+//# sourceMappingURL=negative_zero.js.map

package/esm/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;AACH,MAAM,CAAC,MAAM,aAAa,GAAkB,CAAC,CAAkB,CAAC"}

package/esm/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/esm/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/esm/constants/pi.js

@@ -0,0 +1,9 @@
+/**
+ * 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 const PI = 3.141592653589793;
+//# sourceMappingURL=pi.js.map

package/esm/constants/pi.js.map

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

package/esm/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/esm/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/esm/constants/positive_infinity.js

@@ -0,0 +1,13 @@
+/**
+ * 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 const POSITIVE_INFINITY = 1 / 0;
+export { POSITIVE_INFINITY as Infinity };
+//# sourceMappingURL=positive_infinity.js.map

package/esm/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;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAsB,CAAC,GAAG,CAAsB,CAAC;AAmB/E,OAAO,EAAE,iBAAiB,IAAI,QAAQ,EAAE,CAAC"}

package/esm/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/esm/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/esm/constants/positive_zero.js

@@ -0,0 +1,33 @@
+/**
+ * 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
+ */
+// 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
+ * ```
+ */
+export const POSITIVE_ZERO = 0;
+//# sourceMappingURL=positive_zero.js.map

package/esm/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;AACH,MAAM,CAAC,MAAM,aAAa,GAAkB,CAAkB,CAAC"}

package/esm/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/esm/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/esm/constants/sqrt1_2.js

@@ -0,0 +1,8 @@
+/**
+ * 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 const SQRT1_2 = 0.7071067811865476;
+//# sourceMappingURL=sqrt1_2.js.map

package/esm/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;AACH,MAAM,CAAC,MAAM,OAAO,GAAY,kBAAkB,CAAC"}

package/esm/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/esm/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/esm/constants/sqrt2.js

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

package/esm/constants/sqrt2.js.map

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

package/esm/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/esm/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/esm/cos.js

@@ -0,0 +1,29 @@
+/**
+ * Calculates the cosine of a number, returning a value in the range `[-1, 1]`.
+ *
+ * @module cos
+ */
+import { abs } from "./abs.js";
+import { EPSILON } from "./constants/epsilon.js";
+import { NAN } from "./constants/nan.js";
+import { isFinite } from "./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
+ */
+export function cos(x) {
+    if (!isFinite(x))
+        return NAN;
+    let sum = 1, term = 1, n = 0;
+    while (abs(term) > EPSILON) {
+        n += 2;
+        term *= -x * x / (n * (n - 1));
+        sum += term;
+    }
+    return sum;
+}
+//# sourceMappingURL=cos.js.map

package/esm/cos.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cos.js","sourceRoot":"","sources":["../src/cos.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACjD,OAAO,EAAE,GAAG,EAAE,MAAM,oBAAoB,CAAC;AACzC,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAE9C;;;;;;;GAOG;AACH,MAAM,UAAU,GAAG,CAAC,CAAS;IAC3B,IAAI,CAAC,QAAQ,CAAC,CAAC,CAAC;QAAE,OAAO,GAAG,CAAC;IAE7B,IAAI,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC;IAC7B,OAAO,GAAG,CAAC,IAAI,CAAC,GAAG,OAAO,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/esm/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/esm/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/esm/cosh.js

@@ -0,0 +1,18 @@
+/**
+ * Calculates the hyperbolic cosine of a number.
+ *
+ * @module cosh
+ */
+import { exp } from "./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
+ */
+export function cosh(x) {
+    return (exp(x) + exp(-x)) / 2;
+}
+//# sourceMappingURL=cosh.js.map