@danielsimonjr/mathts-functions 0.2.3 → 0.2.4

package/dist/typed/relational.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Typed Relational Functions
+ *
+ * Polymorphic relational operations using typed-function for runtime dispatch.
+ * Supports number, BigNumber, Fraction, Complex, bigint, boolean, string, and Array types.
+ *
+ * These are clean implementations using mathTyped dispatch — the dormant synced
+ * layer under functions/src/relational/ is left untouched and used only as an
+ * algorithm reference.
+ *
+ * Semantics follow the mathjs convention:
+ *   - nearlyEqual tolerance uses DEFAULT_CONFIG.relTol / absTol.
+ *   - deepEqual recurses over nested arrays; non-array scalars delegate to equalScalar.
+ *   - compareNatural orders mixed types by type name (natural sort) as a tiebreak.
+ *   - compareText is pure lexicographic (locale-independent).
+ *   - equalText delegates to compareText === 0.
+ *   - equalScalar uses tolerance for number/BigNumber/Complex; exact for others.
+ *   - unequal is the negation of equalScalar (with null/undefined strict handling).
+ *   - compareUnits requires same-base units; delegates value comparison recursively.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Test whether two scalar values are nearly equal.
+ *
+ * Uses configured relTol / absTol for number, BigNumber, and Complex.
+ * Uses exact equality for Fraction, bigint, and boolean.
+ * null and undefined only equal themselves.
+ *
+ * @example
+ * ```typescript
+ * equalScalar(1, 1)                             // true
+ * equalScalar(1, 1 + 1e-16)                     // true (within tolerance)
+ * equalScalar(new Fraction(1, 3), new Fraction(1, 3))  // true
+ * equalScalar(null, null)                        // true
+ * equalScalar(null, 0)                           // false
+ * ```
+ */
+export declare const equalScalar: import("typed-function").TypedFunction;
+/**
+ * Test whether two values are unequal.
+ *
+ * null and undefined are compared strictly: null is only equal to null,
+ * undefined is only equal to undefined.
+ *
+ * @example
+ * ```typescript
+ * unequal(2 + 2, 3)       // true
+ * unequal(2 + 2, 4)       // false
+ * unequal(0, null)         // true
+ * ```
+ */
+export declare const unequal: import("typed-function").TypedFunction;
+/**
+ * Test element-wise whether two arrays (or scalars) are equal.
+ *
+ * For arrays: recursively tests each element pair; arrays of different lengths
+ * are unequal. For scalars: delegates to equalScalar.
+ *
+ * @example
+ * ```typescript
+ * deepEqual(2, 4)               // false
+ * deepEqual([2, 5, 1], [2, 5, 1])  // true
+ * deepEqual([2, 5, 1], [2, 7, 1])  // false
+ * deepEqual([[1, 2], [3, 4]], [[1, 2], [3, 4]])  // true
+ * ```
+ */
+export declare const deepEqual: import("typed-function").TypedFunction;
+/**
+ * Compare two strings lexically (case-sensitive, locale-independent).
+ * Returns 1 when x > y, -1 when x < y, and 0 when x == y.
+ *
+ * @example
+ * ```typescript
+ * compareText('B', 'A')   // 1
+ * compareText('2', '10')  // 1  (lexicographic; '2' > '1')
+ * compareText('a', 'a')   // 0
+ * ```
+ */
+export declare const compareText: import("typed-function").TypedFunction;
+/**
+ * Check equality of two strings. Comparison is case-sensitive.
+ *
+ * @example
+ * ```typescript
+ * equalText('Hello', 'Hello')  // true
+ * equalText('a', 'A')          // false
+ * ```
+ */
+export declare const equalText: import("typed-function").TypedFunction;
+/**
+ * Compare two values of any type in a deterministic, natural way.
+ *
+ * For numeric types (number, BigNumber, Fraction), uses tolerance-aware comparison.
+ * For strings, uses natural sort (so "10" > "2").
+ * For Complex numbers, compares real part first then imaginary.
+ * For arrays, compares element-by-element then by length.
+ * For objects, compares sorted keys then values.
+ * For mixed types, orders by type name (natural sort as tiebreak).
+ *
+ * Returns 1 when x > y, -1 when x < y, and 0 when x == y.
+ *
+ * @example
+ * ```typescript
+ * compareNatural(6, 1)                // 1
+ * compareNatural('10', '2')           // 1  (natural sort)
+ * compareNatural([1, 2, 4], [1, 2, 3])  // 1
+ * compareNatural({a: 2}, {a: 4})     // -1
+ * ```
+ */
+export declare const compareNatural: import("typed-function").TypedFunction;
+/**
+ * Compare two Unit values.
+ *
+ * Both units must have the same dimensional base; otherwise an error is thrown.
+ * The underlying numeric values are then compared using compareNatural.
+ *
+ * @example
+ * ```typescript
+ * // compareUnits(math.unit('5 cm'), math.unit('40 mm'))  // 1  (5 cm > 4 cm)
+ * ```
+ */
+export declare const compareUnits: import("typed-function").TypedFunction;
+/**
+ * All typed relational functions.
+ */
+export declare const typedRelational: {
+    equalScalar: import("typed-function").TypedFunction;
+    unequal: import("typed-function").TypedFunction;
+    deepEqual: import("typed-function").TypedFunction;
+    compareText: import("typed-function").TypedFunction;
+    equalText: import("typed-function").TypedFunction;
+    compareNatural: import("typed-function").TypedFunction;
+    compareUnits: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=relational.d.ts.map

package/dist/typed/relational.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relational.d.ts","sourceRoot":"","sources":["../../src/typed/relational.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AA0GH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,WAAW,wCAwBtB,CAAC;AAMH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,OAAO,wCAQlB,CAAC;AAMH;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,SAAS,wCAOpB,CAAC;AAmBH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,wCAUtB,CAAC;AAMH;;;;;;;;GAQG;AACH,eAAO,MAAM,SAAS,wCAIpB,CAAC;AAMH;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,cAAc,wCAEzB,CAAC;AAiHH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,wCAmBvB,CAAC;AAMH;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;CAQ3B,CAAC"}

package/dist/typed/set.d.ts

@@ -0,0 +1,145 @@
+/**
+ * Typed Set Functions
+ *
+ * Polymorphic set (multiset) operations using typed-function for runtime dispatch.
+ * Supports `Array` inputs; Matrix inputs are treated as flat arrays.
+ *
+ * All operations follow the mathjs convention:
+ *   - Multi-dimension arrays are flattened before the operation.
+ *   - Set operations respect multiplicity (multiset semantics), matching
+ *     the mathjs `setUnion`, `setIntersect`, etc. behaviour.
+ *   - The "natural" comparison used for identity is strict equality (`===`)
+ *     for primitives and structural for objects (via JSON-stable stringify),
+ *     matching the relevant subset of mathjs's `compareNatural`.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Create the union of two (multi)sets.
+ * Multi-dimension arrays will be flattened before the operation.
+ *
+ * Union = symDifference ∪ intersection (elements from both sets, respecting multiplicity).
+ *
+ * @example
+ * ```typescript
+ * setUnion([1, 2, 3, 4], [3, 4, 5, 6])  // [1, 2, 3, 4, 5, 6]
+ * setUnion([1, 2, 2], [2, 3])            // [1, 2, 2, 3]
+ * ```
+ */
+export declare const setUnion: import("typed-function").TypedFunction;
+/**
+ * Create the intersection of two (multi)sets.
+ * Multi-dimension arrays will be flattened before the operation.
+ *
+ * @example
+ * ```typescript
+ * setIntersect([1, 2, 3, 4], [3, 4, 5, 6])  // [3, 4]
+ * setIntersect([1, 2, 2], [2, 2, 3])         // [2, 2]
+ * ```
+ */
+export declare const setIntersect: import("typed-function").TypedFunction;
+/**
+ * Create the difference of two (multi)sets: elements of a1 not in a2.
+ * Multi-dimension arrays will be flattened before the operation.
+ *
+ * @example
+ * ```typescript
+ * setDifference([1, 2, 3, 4], [3, 4, 5, 6])  // [1, 2]
+ * setDifference([1, 2, 2], [2])               // [1, 2]
+ * ```
+ */
+export declare const setDifference: import("typed-function").TypedFunction;
+/**
+ * Create the symmetric difference of two (multi)sets.
+ * Multi-dimension arrays will be flattened before the operation.
+ *
+ * @example
+ * ```typescript
+ * setSymDifference([1, 2, 3, 4], [3, 4, 5, 6])  // [1, 2, 5, 6]
+ * ```
+ */
+export declare const setSymDifference: import("typed-function").TypedFunction;
+/**
+ * Check whether a (multi)set is a subset of another (multi)set.
+ * Every element of a1 (with multiplicity) must appear in a2.
+ *
+ * @example
+ * ```typescript
+ * setIsSubset([1, 2], [1, 2, 3])  // true
+ * setIsSubset([1, 4], [1, 2, 3])  // false
+ * setIsSubset([], [1, 2])         // true
+ * ```
+ */
+export declare const setIsSubset: import("typed-function").TypedFunction;
+/**
+ * Count how many times a value appears in a multiset.
+ *
+ * @example
+ * ```typescript
+ * setMultiplicity(2, [1, 2, 2, 4])  // 2
+ * setMultiplicity(1, [1, 2, 2, 4])  // 1
+ * setMultiplicity(5, [1, 2, 2, 4])  // 0
+ * ```
+ */
+export declare const setMultiplicity: import("typed-function").TypedFunction;
+/**
+ * Create the powerset of a (multi)set.
+ * Returns all possible subsets ordered by size, then lexicographically.
+ * A multi-dimension array will be flattened before the operation.
+ *
+ * @example
+ * ```typescript
+ * setPowerset([1, 2, 3])
+ * // [[], [1], [2], [3], [1, 2], [1, 3], [2, 3], [1, 2, 3]]
+ * ```
+ */
+export declare const setPowerset: import("typed-function").TypedFunction;
+/**
+ * Collect the distinct elements of a multiset.
+ * A multi-dimension array will be flattened before the operation.
+ *
+ * @example
+ * ```typescript
+ * setDistinct([1, 1, 1, 2, 2, 3])  // [1, 2, 3]
+ * ```
+ */
+export declare const setDistinct: import("typed-function").TypedFunction;
+/**
+ * Count the number of elements of a (multi)set.
+ * When the second argument is `true`, count only unique values.
+ * A multi-dimension array will be flattened before the operation.
+ *
+ * @example
+ * ```typescript
+ * setSize([1, 2, 2, 4])         // 4
+ * setSize([1, 2, 2, 4], true)   // 3
+ * ```
+ */
+export declare const setSize: import("typed-function").TypedFunction;
+/**
+ * Create the Cartesian product of two (multi)sets.
+ * Multi-dimension arrays will be flattened and values will be sorted before the operation.
+ *
+ * @example
+ * ```typescript
+ * setCartesian([1, 2], [3, 4])
+ * // [[1, 3], [1, 4], [2, 3], [2, 4]]
+ * ```
+ */
+export declare const setCartesian: import("typed-function").TypedFunction;
+/**
+ * All typed set functions.
+ */
+export declare const typedSet: {
+    setUnion: import("typed-function").TypedFunction;
+    setIntersect: import("typed-function").TypedFunction;
+    setDifference: import("typed-function").TypedFunction;
+    setSymDifference: import("typed-function").TypedFunction;
+    setIsSubset: import("typed-function").TypedFunction;
+    setMultiplicity: import("typed-function").TypedFunction;
+    setPowerset: import("typed-function").TypedFunction;
+    setDistinct: import("typed-function").TypedFunction;
+    setSize: import("typed-function").TypedFunction;
+    setCartesian: import("typed-function").TypedFunction;
+};
+//# sourceMappingURL=set.d.ts.map

package/dist/typed/set.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set.d.ts","sourceRoot":"","sources":["../../src/typed/set.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAuGH;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,QAAQ,wCAYnB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,wCAOvB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,aAAa,wCAQxB,CAAC;AAMH;;;;;;;;GAQG;AACH,eAAO,MAAM,gBAAgB,wCAQ3B,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,wCAgBtB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,wCAU1B,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,WAAW,wCAmBtB,CAAC;AAMH;;;;;;;;GAQG;AACH,eAAO,MAAM,WAAW,wCAYtB,CAAC;AAMH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,OAAO,wCAalB,CAAC;AAMH;;;;;;;;;GASG;AACH,eAAO,MAAM,YAAY,wCAavB,CAAC;AA0CH;;GAEG;AACH,eAAO,MAAM,QAAQ;;;;;;;;;;;CAWpB,CAAC"}