nerdamer 1.1.13 → 2.0.0-rc.1

package/output/solve/solveSystem.js

@@ -0,0 +1,290 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveSystem = solveSystem;
+const adapters_1 = require("../algebra/adapters");
+const groebnerBase_1 = require("../algebra/algorithms/groebnerBase");
+const ratsimp_1 = require("../algebra/simplify/ratsimp");
+const Dictionary_1 = require("../core/classes/dictionary/Dictionary");
+const Equation_1 = require("../core/classes/equation/Equation");
+const analysis_1 = require("../core/classes/expression/analysis");
+const collect_1 = require("../core/classes/expression/collect");
+const Expression_1 = require("../core/classes/expression/Expression");
+const shortcuts_1 = require("../core/classes/expression/shortcuts");
+const constants_1 = require("../core/classes/parser/constants");
+const Parser_1 = require("../core/classes/parser/Parser");
+const Polynomial_1 = require("../core/classes/polynomial/Polynomial");
+const Vector_1 = require("../core/classes/vector/Vector");
+const errors_1 = require("../core/errors");
+const MultivariateSolver_1 = require("./classes/MultivariateSolver");
+const linsolve_1 = require("./linsolve");
+const solve_1 = require("./solve");
+function toExpression(input) {
+    if (Equation_1.Equation.isEquation(input)) {
+        return input.toLHS().LHS;
+    }
+    if (Expression_1.Expression.isExpression(input)) {
+        return input;
+    }
+    const parsed = Parser_1.Parser.parse(String(input));
+    if (Equation_1.Equation.isEquation(parsed)) {
+        return parsed.toLHS().LHS;
+    }
+    if (Expression_1.Expression.isExpression(parsed)) {
+        return parsed;
+    }
+    throw new errors_1.UnexpectedInputError((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[parsed.dataType] }));
+}
+function normalizeEquations(equations) {
+    if (Vector_1.Vector.isVector(equations)) {
+        const result = [];
+        for (let i = 0; i < equations.count(); i++) {
+            result.push(toExpression(equations.__get__([i])));
+        }
+        return result;
+    }
+    return equations.map(eq => toExpression(eq));
+}
+function symbolicBackSubstitution(basisExprs, vars) {
+    let partials = [
+        { assignment: new Map(), basis: basisExprs },
+    ];
+    for (let i = vars.length - 1; i >= 0; i--) {
+        const v = vars[i];
+        const unsolved = new Set(vars.slice(0, i));
+        const nextPartials = [];
+        for (const { assignment, basis } of partials) {
+            const univariates = basis.filter(expr => {
+                if (expr.isZero()) {
+                    return false;
+                }
+                const exprVars = expr.variables();
+                if (!exprVars.includes(v)) {
+                    return false;
+                }
+                for (const ev of exprVars) {
+                    if (unsolved.has(ev)) {
+                        return false;
+                    }
+                }
+                return true;
+            });
+            if (univariates.length === 0) {
+                nextPartials.push({ assignment: new Map(assignment), basis });
+                continue;
+            }
+            const solutions = (0, solve_1.solve)(univariates[0], v);
+            const roots = solutions.elements;
+            for (const root of roots) {
+                let consistent = true;
+                for (let k = 1; k < univariates.length; k++) {
+                    const substituted = univariates[k].subst(v, root);
+                    if (substituted.isConstant() && !substituted.isNearlyZero()) {
+                        consistent = false;
+                        break;
+                    }
+                }
+                if (!consistent) {
+                    continue;
+                }
+                const newBasis = basis.map(expr => {
+                    if (!expr.hasVariable(v)) {
+                        return expr;
+                    }
+                    const exprVars = expr.variables();
+                    const hasUnsolvedVars = exprVars.some(ev => unsolved.has(ev));
+                    if (!hasUnsolvedVars && exprVars.length === 1 && exprVars[0] === v) {
+                        return (0, shortcuts_1.zero)();
+                    }
+                    return expr.subst(v, root);
+                });
+                const ext = new Map(assignment);
+                ext.set(v, root);
+                nextPartials.push({ assignment: ext, basis: newBasis });
+            }
+        }
+        partials = nextPartials;
+    }
+    return partials.map(p => p.assignment);
+}
+function solutionsToDictionaries(solutions, vars) {
+    const dictionaries = [];
+    for (const solution of solutions) {
+        if (solution.size !== vars.length) {
+            throw new errors_1.UnsupportedOperationError((0, errors_1.message)('solveSystemInfiniteSolutions'));
+        }
+        const dictionary = new Dictionary_1.Dictionary();
+        for (const variable of vars) {
+            const value = solution.get(variable);
+            if (!value) {
+                throw new errors_1.UnsupportedOperationError((0, errors_1.message)('solveSystemInfiniteSolutions'));
+            }
+            dictionary.set(variable, value);
+        }
+        dictionaries.push(dictionary);
+    }
+    return dictionaries;
+}
+function isSystemSolution(expressions, domainRestrictions, solution) {
+    const values = {};
+    for (const [variable, value] of solution) {
+        values[variable] = value;
+    }
+    let retval = true;
+    try {
+        // A cleared denominator remains part of the original equation's domain.
+        // If it cannot be shown to be nonzero for this candidate, the rewrite is not
+        // sufficient to certify the candidate as a solution.
+        for (const restriction of domainRestrictions) {
+            const evaluated = restriction.evaluate(values);
+            if (!evaluated.isConstant() || evaluated.isZero()) {
+                retval = false;
+                break;
+            }
+        }
+        if (retval) {
+            for (const expression of expressions) {
+                const evaluated = expression.evaluate(values);
+                if (!evaluated.isConstant() || !evaluated.isNearlyZero()) {
+                    retval = false;
+                    break;
+                }
+            }
+        }
+    }
+    catch {
+        retval = false;
+    }
+    return retval;
+}
+/**
+ * Solves a system of expressions or equations for an ordered set of variables.
+ *
+ * Expressions are interpreted as equal to zero. The solver first tries exact
+ * linear reduction, then a lexicographic Groebner basis with symbolic back
+ * substitution for polynomial systems, and finally multivariate Newton-Raphson
+ * over a fixed search interval. Rational polynomial systems may have denominators
+ * cleared for symbolic work; candidates are checked against the original domain.
+ *
+ * @remarks
+ * The nonlinear numerical fallback is heuristic and does not guarantee all
+ * roots. A returned outer {@link Vector} contains one {@link Dictionary} per
+ * solution. An empty system has one empty solution, while no discovered or
+ * inconsistent solution is represented by an empty Vector.
+ *
+ * Infinite nonlinear solution sets are not represented. Underdetermined
+ * systems that reach numerical fallback are rejected.
+ *
+ * @param equations - Vector or array of equations and zero-valued expressions.
+ * @param variables - Optional variable order. When omitted, variables are
+ * collected from the normalized expressions.
+ * @returns A Vector of solution dictionaries keyed by variable name.
+ * @throws {@link core!UnexpectedInputError} If an input cannot be normalized to an
+ * Expression or Equation.
+ * @throws {@link core!UnsupportedOperationError} If a solution is not isolated or an
+ * underdetermined nonlinear system reaches numerical fallback.
+ */
+function solveSystem(equations, variables) {
+    const expressions = normalizeEquations(equations);
+    if (expressions.length === 0) {
+        return new Vector_1.Vector([new Dictionary_1.Dictionary()]);
+    }
+    const vars = variables ?? (0, collect_1.collectVariablesSet)(expressions);
+    if (vars.length === 0) {
+        return expressions.every(e => e.isZero()) ? new Vector_1.Vector([new Dictionary_1.Dictionary()]) : new Vector_1.Vector([]);
+    }
+    // Rational equations can still be polynomial equations after their denominators are
+    // cleared. Keep the original expressions for domain checks and numerical fallback,
+    // and only use the rewritten forms for symbolic solving.
+    const symbolicExpressions = [];
+    const domainRestrictions = [];
+    let hasRationalRewrite = false;
+    for (const expression of expressions) {
+        let symbolicExpression = expression;
+        if (!expression.isPolynomialLike()) {
+            const rational = (0, ratsimp_1.toCommonDenominator)(expression);
+            const numerator = rational.getNumerator().expand();
+            const denominator = rational.getDenominator().expand();
+            if (!denominator.isOne() &&
+                numerator.isPolynomialLike() &&
+                denominator.isPolynomialLike()) {
+                symbolicExpression = numerator;
+                domainRestrictions.push(denominator);
+                hasRationalRewrite = true;
+            }
+        }
+        symbolicExpressions.push(symbolicExpression);
+    }
+    // 1. Try linear solver
+    try {
+        const linear = (0, linsolve_1.solveLinearSystem)(symbolicExpressions, vars);
+        if (linear.type === 'inconsistent') {
+            return new Vector_1.Vector([]);
+        }
+        if (linear.type === 'infinite') {
+            if (!hasRationalRewrite) {
+                const dictionary = new Dictionary_1.Dictionary();
+                for (const variable of vars) {
+                    if (variable in linear.solutions) {
+                        dictionary.set(variable, linear.solutions[variable]);
+                    }
+                }
+                return new Vector_1.Vector([dictionary]);
+            }
+        }
+        else {
+            const dictionary = new Dictionary_1.Dictionary();
+            const solution = new Map();
+            for (const variable of vars) {
+                if (variable in linear.solutions) {
+                    const value = linear.solutions[variable];
+                    dictionary.set(variable, value);
+                    solution.set(variable, value);
+                }
+            }
+            if (!hasRationalRewrite || isSystemSolution(expressions, domainRestrictions, solution)) {
+                return new Vector_1.Vector([dictionary]);
+            }
+            return new Vector_1.Vector([]);
+        }
+    }
+    catch (error) {
+        if (!(error instanceof Error) || !error.message.includes('Nonlinear term detected')) {
+            throw error;
+        }
+    }
+    // 2. Nonlinear polynomial: Gröbner basis + symbolic back-substitution
+    const allPolynomial = symbolicExpressions.every(e => e.isPolynomialLike());
+    if (allPolynomial) {
+        try {
+            const polys = symbolicExpressions.map(expression => {
+                const cleared = (0, analysis_1.normalizeMultiplierDenominators)(expression);
+                return (0, adapters_1.polynomialToMultiPoly)(new Polynomial_1.Polynomial(cleared, vars), vars).poly;
+            });
+            const basis = (0, groebnerBase_1.Groebner)(polys, vars, 'LEX', true);
+            if (basis.length === 1 && basis[0].isConstant() && basis[0].constantTerm() !== 0n) {
+                return new Vector_1.Vector([]);
+            }
+            const basisExprs = basis.map(p => (0, adapters_1.multiPolyToExpression)(p, vars));
+            let solutions = symbolicBackSubstitution(basisExprs, vars);
+            if (hasRationalRewrite) {
+                solutions = solutions.filter(solution => isSystemSolution(expressions, domainRestrictions, solution));
+            }
+            if (solutions.length > 0) {
+                return new Vector_1.Vector(solutionsToDictionaries(solutions, vars));
+            }
+        }
+        catch {
+            // Fall through to numeric solver
+        }
+    }
+    // 3. Numeric fallback: multivariate Newton-Raphson
+    if (expressions.length < vars.length) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('solveSystemInfiniteSolutions'));
+    }
+    const solver = new MultivariateSolver_1.MultivariateSolver(expressions, vars);
+    const numericSolutions = solver.roots();
+    if (numericSolutions.length === 0) {
+        return new Vector_1.Vector([]);
+    }
+    return new Vector_1.Vector(solutionsToDictionaries(numericSolutions, vars));
+}

package/output/solve/utils.d.ts

@@ -0,0 +1,9 @@
+import { Equation } from '../core/classes/equation/Equation';
+import { Expression } from '../core/classes/expression/Expression';
+import type { ExpressionInput } from '../core/types';
+export interface SolverInputs {
+    x: string;
+    expression: Expression;
+}
+export declare function extractVariable(variable: ExpressionInput): string;
+export declare function prepareSolverInputs(input: ExpressionInput | Equation | string, variable?: ExpressionInput): SolverInputs;

package/output/solve/utils.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractVariable = extractVariable;
+exports.prepareSolverInputs = prepareSolverInputs;
+const Equation_1 = require("../core/classes/equation/Equation");
+const Expression_1 = require("../core/classes/expression/Expression");
+const constants_1 = require("../core/classes/parser/constants");
+const Parser_1 = require("../core/classes/parser/Parser");
+const errors_1 = require("../core/errors");
+function extractVariable(variable) {
+    variable = Expression_1.Expression.create(variable);
+    if (!variable.isPlainVariable()) {
+        throw new errors_1.UnexpectedInputError((0, errors_1.message)('plainVariableExpected', { input: variable.text() }));
+    }
+    return variable.value;
+}
+function prepareSolverInputs(input, variable) {
+    let expression;
+    if (Equation_1.Equation.isEquation(input)) {
+        expression = input.toLHS().LHS;
+    }
+    else if (!Expression_1.Expression.isExpression(input)) {
+        // Cast them all to string
+        const parsed = Parser_1.Parser.parse(String(input));
+        // Was it an equation string?
+        if (Equation_1.Equation.isEquation(parsed)) {
+            expression = parsed.toLHS().LHS;
+        }
+        else if (!Expression_1.Expression.isExpression(parsed)) {
+            // Complain for any other types
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('expressionExpected', { type: constants_1.dataTypes[parsed.dataType] }));
+        }
+        else {
+            expression = parsed;
+        }
+    }
+    else {
+        expression = input;
+    }
+    const vars = expression.variables();
+    let x;
+    // Get the variable to solve for
+    if (!variable) {
+        if (vars.length === 1) {
+            x = vars[0];
+        }
+        else {
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('tooManyUnknowns'));
+        }
+    }
+    else {
+        x = extractVariable(variable);
+        if (x && vars[0] && !vars.includes(x)) {
+            // Rethink. Throw a better error message.
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('tooManyUnknowns'));
+        }
+    }
+    return {
+        expression,
+        x,
+    };
+}

package/output/utils/array.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Removes an element from an array
+ * @param arr
+ * @param value
+ * @returns
+ */
+export declare function remove<T>(arr: T[], value: T): T[];
+/**
+ * Checks if two array are equal/having the same elements
+ *
+ * @param arr1
+ * @param arr2
+ * @returns
+ */
+export declare function isEqualArray<T>(arr1: T[], arr2: T[]): boolean;
+/**
+ * Combines an array and sorts it
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+export declare function combinedArray<T>(a: T[], b: T[]): T[];
+/**
+ * IMPROVE: Look into using Set.intersection
+ * Gets the intersection of two arrays. This can probably be replaced with Set.intersection in the future
+ *
+ * @param arr1
+ * @param arr2
+ * @returns
+ */
+export declare function intersection<T>(arr1: T[], arr2: T[]): T[];
+/**
+ * Sorts two arrays in the same other maintaining the indices of the values
+ *
+ * @param arr1
+ * @param arr2
+ * @param compareFn
+ * @returns
+ */
+export declare function syncSort<T>(arr1: T[], arr2: T[], compareFn: (a: T, b: T) => number): T[][];
+export declare function allEqual<T>(arr: T[]): boolean;

package/output/utils/array.js

@@ -0,0 +1,98 @@
+"use strict";
+/* --------------------- ABOUT THIS LIB --------------------- */
+// This library ideally does not utilize any of the classes in nerdamer and sticks to pure TypeScript
+// Use core.math.utils instead if it's a library specific utility function.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remove = remove;
+exports.isEqualArray = isEqualArray;
+exports.combinedArray = combinedArray;
+exports.intersection = intersection;
+exports.syncSort = syncSort;
+exports.allEqual = allEqual;
+/**
+ * Removes an element from an array
+ * @param arr
+ * @param value
+ * @returns
+ */
+function remove(arr, value) {
+    const index = arr.indexOf(value);
+    if (index > -1) {
+        arr.splice(index, 1);
+    }
+    return arr;
+}
+/**
+ * Checks if two array are equal/having the same elements
+ *
+ * @param arr1
+ * @param arr2
+ * @returns
+ */
+function isEqualArray(arr1, arr2) {
+    // If they're not the same length then we're done
+    if (arr1.length !== arr2.length) {
+        return false;
+    }
+    // Check each element
+    for (const a of arr1) {
+        if (!arr2.includes(a)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Combines an array and sorts it
+ *
+ * @param a
+ * @param b
+ * @returns
+ */
+function combinedArray(a, b) {
+    return [...new Set(a.concat(b))].sort();
+}
+/**
+ * IMPROVE: Look into using Set.intersection
+ * Gets the intersection of two arrays. This can probably be replaced with Set.intersection in the future
+ *
+ * @param arr1
+ * @param arr2
+ * @returns
+ */
+function intersection(arr1, arr2) {
+    // Ensure that we're looping over the shorter array
+    if (arr1.length > arr2.length) {
+        return intersection(arr2, arr1);
+    }
+    const retval = [];
+    for (const e of arr1) {
+        if (arr2.includes(e)) {
+            retval.push(e);
+        }
+    }
+    return retval;
+}
+/**
+ * Sorts two arrays in the same other maintaining the indices of the values
+ *
+ * @param arr1
+ * @param arr2
+ * @param compareFn
+ * @returns
+ */
+function syncSort(arr1, arr2, compareFn) {
+    const indices = arr1.map((_, index) => index);
+    indices.sort((a, b) => compareFn(arr1[a], arr1[b]));
+    const sortedArr1 = indices.map(index => arr1[index]);
+    const sortedArr2 = indices.map(index => arr2[index]);
+    return [sortedArr1, sortedArr2];
+}
+function allEqual(arr) {
+    // An empty array is considered to have all elements "the same"
+    if (arr.length === 0) {
+        return true;
+    }
+    const firstElement = arr[0];
+    return arr.every(element => element === firstElement);
+}

package/output/utils/debug.d.ts

@@ -0,0 +1,131 @@
+import { Expression } from '../core/classes/expression/Expression';
+import { Polynomial } from '../core/classes/polynomial/Polynomial';
+import { Scope } from '../core/common/classes/Scope';
+import type { ParserValuesObject } from '../core/classes/parser/types';
+import type { Term } from '../core/classes/polynomial/Term';
+import type { ParserEntity } from '../core/types';
+export interface DebugToken {
+    kind: 'token';
+    position: number;
+    text: string;
+    type: string | null;
+    value: string;
+}
+export interface DebugScope {
+    column: number;
+    deferLHSResolution: boolean;
+    deferRHSResolution: boolean;
+    depth: number;
+    implicitMultiply: boolean;
+    isOpen: boolean;
+    items: DebugScopeItem[];
+    kind: 'scope';
+    text: string;
+    type: string;
+    typedText: string;
+}
+export type DebugScopeItem = DebugScope | DebugToken;
+export interface DebugExpression {
+    args: DebugExpression[] | null;
+    base: DebugExpression | null;
+    dataType: string;
+    deferred: boolean;
+    elements: Record<string, DebugExpression> | null;
+    kind: 'Expression';
+    multiplier: string | null;
+    name: string | null;
+    power: DebugExpression | null;
+    precision: number | null;
+    text: string;
+    type: number;
+    typeName: string;
+    value: string;
+}
+export interface DebugEquation {
+    LHS: DebugExpression;
+    RHS: DebugExpression;
+    dataType: string;
+    kind: 'Equation';
+    text: string;
+}
+export interface DebugVector {
+    dataType: string;
+    elements: DebugEntity[];
+    kind: 'Vector';
+    text: string;
+}
+export interface DebugMatrix {
+    dataType: string;
+    elements: DebugExpression[][];
+    kind: 'Matrix';
+    text: string;
+}
+export interface DebugValuesSet {
+    dataType: string;
+    elements: DebugEntity[];
+    kind: 'ValuesSet';
+    text: string;
+}
+export interface DebugCollection {
+    dataType: string;
+    elements: DebugEntity[];
+    kind: 'Collection';
+    text: string;
+}
+export interface DebugDictionaryEntry {
+    key: string;
+    value: DebugEntity;
+}
+export interface DebugDictionary {
+    dataType: string;
+    entries: DebugDictionaryEntry[];
+    kind: 'Dictionary';
+    text: string;
+}
+export type DebugEntity = DebugExpression | DebugEquation | DebugVector | DebugMatrix | DebugValuesSet | DebugCollection | DebugDictionary;
+export interface DebugTerm {
+    coefficient: DebugExpression;
+    kind: 'Term';
+    multidegree: number[];
+    powers: Record<string, number>;
+    text: string;
+    totalPower: number;
+    variables: string[];
+}
+export interface DebugPolynomial {
+    expression: DebugExpression;
+    isMultivariate: boolean;
+    kind: 'Polynomial';
+    ordering: string;
+    terms: DebugTerm[];
+    text: string;
+    variables: string[];
+}
+export interface ParseInspection {
+    normalizedSource: string;
+    result: DebugEntity;
+    rpn: DebugScope;
+    source: string;
+    tokens: DebugScope;
+}
+export declare function createTypesMap(): Record<number, string>;
+/** Converts a parser token scope to JSON-safe diagnostic data. */
+export declare function inspectTokens(scope: Scope): DebugScope;
+/** Converts an Expression tree to JSON-safe diagnostic data without changing it. */
+export declare function inspectExpressionData(obj: Expression): DebugExpression;
+/** Converts any current parser entity to plain diagnostic data. */
+export declare function inspectEntity(entity: ParserEntity): DebugEntity;
+/** Inspects one parser input using the same preprocessing as Parser.parse(). */
+export declare function inspectParse(source: string, values?: ParserValuesObject): ParseInspection;
+/** Converts a polynomial Term to JSON-safe diagnostic data without touching its caches. */
+export declare function inspectTermData(t: Term): DebugTerm;
+/** Converts a Polynomial to JSON-safe diagnostic data. */
+export declare function inspectPolynomialData(p: Polynomial): DebugPolynomial;
+export declare function printE(obj: Record<string, unknown>): void;
+export declare const printTokens: (tokens: Scope, valuesOnly?: boolean) => void;
+export declare const printRPN: (str: string) => void;
+export declare function inspectExpression(obj: Expression, depth?: number): string;
+export declare function inspectTerm(t: Term): string;
+export declare function inspectPolynomial(p: Polynomial): string;
+export declare function hr(symbol?: string, length?: number): void;
+export declare function simpleSerialize(obj: Record<string, unknown>): string;