nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/dispatch.js

@@ -0,0 +1,304 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mathFunctionRegistry = void 0;
+const factor_1 = require("../algebra/factor/factor");
+const gcd_1 = require("../algebra/gcd/gcd");
+const groebner_1 = require("../algebra/groebner");
+const partfrac_1 = require("../algebra/partfrac");
+const simplify_1 = require("../algebra/simplify/simplify");
+const utils_1 = require("../algebra/utils");
+const diff_1 = require("../calculus/derivative/diff");
+const fresnel_1 = require("../calculus/fresnel");
+const integrate_1 = require("../calculus/integrate/integrate");
+const ilaplace_1 = require("../calculus/laplace/ilaplace");
+const laplace_1 = require("../calculus/laplace/laplace");
+const limit_1 = require("../calculus/limit/limit");
+const geometry_1 = require("../math/geometry");
+const math_1 = require("../math/math");
+const trig_1 = require("../math/trig");
+const trunc_1 = require("../math/trunc");
+const utils_2 = require("../math/utils");
+const solve_1 = require("../solve/solve");
+const solveSystem_1 = require("../solve/solveSystem");
+const assume_1 = require("./classes/assumption/assume");
+const Collection_1 = require("./classes/collection/Collection");
+const Dictionary_1 = require("./classes/dictionary/Dictionary");
+const Equation_1 = require("./classes/equation/Equation");
+const shortcuts_1 = require("./classes/expression/shortcuts");
+const utils_3 = require("./classes/expression/utils");
+const functions_1 = require("./classes/matrix/functions");
+const Matrix_1 = require("./classes/matrix/Matrix");
+const utils_4 = require("./classes/matrix/utils");
+const constants_1 = require("./classes/parser/constants");
+const controlFlow_1 = require("./classes/parser/scripting/controlFlow");
+const evaluate_1 = require("./classes/parser/scripting/evaluate");
+const scope_1 = require("./classes/parser/scripting/scope");
+const functions_2 = require("./classes/polynomial/functions");
+const ValuesSet_1 = require("./classes/valuesSet/ValuesSet");
+const functions_3 = require("./classes/vector/functions");
+const Vector_1 = require("./classes/vector/Vector");
+const errors_1 = require("./errors");
+const complex_1 = require("./functions/complex");
+const expand_1 = require("./functions/expand/expand");
+const subst_1 = require("./functions/subst");
+/**
+ * Registers a system-level function in the dispatch table. Registered functions can use
+ * narrower parameter types, so `RegisteredMathFunction` does not define a common argument
+ * type. Dynamic invocation is handled by `callFunction`.
+ */
+function entry(opts) {
+    return {
+        fn: opts.fn,
+        minArgs: opts.minArgs,
+        maxArgs: opts.maxArgs,
+        maxPrecision: opts.maxPrecision,
+        equationArgs: opts.equationArgs,
+        distElWise: opts.distElWise,
+        deferArguments: opts.deferArguments,
+        normalizeDeferredArguments: opts.normalizeDeferredArguments,
+        bracketlessStatement: opts.bracketlessStatement,
+        returnBoundary: opts.returnBoundary,
+        usage: opts.usage ?? 'notation',
+        level: 'system',
+    };
+}
+/** Applies parser differentiation to both sides when the input is an Equation. */
+function parserDiff(expr, variable, n) {
+    let retval;
+    if (Equation_1.Equation.isEquation(expr)) {
+        retval = expr.each(e => parserDiff(e, variable, n));
+    }
+    else {
+        retval = (0, diff_1.diff)(expr, variable, n);
+    }
+    return retval;
+}
+/** Applies parser integration to both sides when the input is an Equation. */
+function parserIntegrate(expr, variable) {
+    let retval;
+    if (Equation_1.Equation.isEquation(expr)) {
+        retval = expr.each(e => parserIntegrate(e, variable));
+    }
+    else {
+        retval = (0, integrate_1.integrate)(expr, variable);
+    }
+    return retval;
+}
+/** Maps the parser's symbolic direction token to the public limit direction representation. */
+function parserLimit(expr, x, val, dir) {
+    let direction = 'both';
+    if (dir) {
+        direction = (0, utils_3.assertPlainVariableAndGetString)(dir);
+    }
+    const retval = (0, limit_1.limit)(expr, x, val, direction);
+    return retval;
+}
+/** Completes the square while returning the parser-facing expression result. */
+function parserSqcomp(expr, variable) {
+    const variableName = variable === undefined ? undefined : (0, utils_3.assertPlainVariableAndGetString)(variable);
+    const retval = (0, utils_1.sqcomp)(expr, variableName).expression;
+    return retval;
+}
+/** Iterates parser containers while keeping the iteration variable local to each body call. */
+function parserEach(collection, variable, body) {
+    const target = collection();
+    const values = [];
+    if (Vector_1.Vector.isVector(target) ||
+        Collection_1.Collection.isCollection(target) ||
+        ValuesSet_1.ValuesSet.isValuesSet(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else if (Matrix_1.Matrix.isMatrix(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else if (Dictionary_1.Dictionary.isDictionary(target)) {
+        target.forEach(value => values.push(value.copy()));
+    }
+    else {
+        throw new errors_1.UnexpectedDataType((0, errors_1.message)('unsupportedType', { type: constants_1.dataTypes[target.dataType] }));
+    }
+    let index = 0;
+    const retval = (0, controlFlow_1.FOR)(() => (0, shortcuts_1.zero)(), () => (index < values.length ? (0, shortcuts_1.one)() : (0, shortcuts_1.zero)()), () => {
+        index++;
+        return (0, shortcuts_1.zero)();
+    }, () => (0, scope_1.LET)(variable, () => values[index], body));
+    return retval;
+}
+exports.mathFunctionRegistry = {
+    // Trigonometric
+    cos: entry({ fn: trig_1.cos, minArgs: 1, maxArgs: 1, distElWise: true }),
+    sin: entry({ fn: trig_1.sin, minArgs: 1, maxArgs: 1, distElWise: true }),
+    tan: entry({ fn: trig_1.tan, minArgs: 1, maxArgs: 1, distElWise: true }),
+    sec: entry({ fn: trig_1.sec, minArgs: 1, maxArgs: 1, distElWise: true }),
+    csc: entry({ fn: trig_1.csc, minArgs: 1, maxArgs: 1, distElWise: true }),
+    cot: entry({ fn: trig_1.cot, minArgs: 1, maxArgs: 1, distElWise: true }),
+    acos: entry({ fn: trig_1.acos, minArgs: 1, maxArgs: 1, distElWise: true }),
+    asin: entry({ fn: trig_1.asin, minArgs: 1, maxArgs: 1, distElWise: true }),
+    atan: entry({ fn: trig_1.atan, minArgs: 1, maxArgs: 1, distElWise: true }),
+    asec: entry({ fn: trig_1.asec, minArgs: 1, maxArgs: 1, distElWise: true }),
+    acsc: entry({ fn: trig_1.acsc, minArgs: 1, maxArgs: 1, distElWise: true }),
+    acot: entry({ fn: trig_1.acot, minArgs: 1, maxArgs: 1, distElWise: true }),
+    atan2: entry({ fn: trig_1.atan2, minArgs: 2, maxArgs: 2, distElWise: true }),
+    cosh: entry({ fn: trig_1.cosh, minArgs: 1, maxArgs: 1, distElWise: true }),
+    sinh: entry({ fn: trig_1.sinh, minArgs: 1, maxArgs: 1, distElWise: true }),
+    tanh: entry({ fn: trig_1.tanh, minArgs: 1, maxArgs: 1, distElWise: true }),
+    sech: entry({ fn: trig_1.sech, minArgs: 1, maxArgs: 1, distElWise: true }),
+    csch: entry({ fn: trig_1.csch, minArgs: 1, maxArgs: 1, distElWise: true }),
+    coth: entry({ fn: trig_1.coth, minArgs: 1, maxArgs: 1, distElWise: true }),
+    acosh: entry({ fn: trig_1.acosh, minArgs: 1, maxArgs: 1, distElWise: true }),
+    asinh: entry({ fn: trig_1.asinh, minArgs: 1, maxArgs: 1, distElWise: true }),
+    atanh: entry({ fn: trig_1.atanh, minArgs: 1, maxArgs: 1, distElWise: true }),
+    asech: entry({ fn: trig_1.asech, minArgs: 1, maxArgs: 1, distElWise: true }),
+    acsch: entry({ fn: trig_1.acsch, minArgs: 1, maxArgs: 1, distElWise: true }),
+    acoth: entry({ fn: trig_1.acoth, minArgs: 1, maxArgs: 1, distElWise: true }),
+    // Math
+    abs: entry({ fn: math_1.abs, minArgs: 1, maxArgs: 1, distElWise: true }),
+    sqrt: entry({ fn: math_1.sqrt, minArgs: 1, maxArgs: 1, distElWise: true }),
+    nthroot: entry({ fn: math_1.nthroot, minArgs: 2, maxArgs: 2, distElWise: true }),
+    cbrt: entry({ fn: math_1.cbrt, minArgs: 1, maxArgs: 1, distElWise: true }),
+    subst: entry({ fn: subst_1.subst, minArgs: 3, maxArgs: 3, distElWise: true }),
+    log: entry({ fn: math_1.log, minArgs: 1, maxArgs: 2, distElWise: true }),
+    exp: entry({ fn: math_1.exp, minArgs: 1, maxArgs: 1, distElWise: true }),
+    erf: entry({ fn: math_1.erf, minArgs: 1, maxArgs: 1, distElWise: true }),
+    erfc: entry({ fn: math_1.erfc, minArgs: 1, maxArgs: 1, distElWise: true }),
+    gamma: entry({ fn: math_1.gamma, minArgs: 1, maxArgs: 1, distElWise: true }),
+    [constants_1.DIRAC]: entry({ fn: math_1.dirac, minArgs: 1, maxArgs: 1, distElWise: true }),
+    [constants_1.HEAVISIDE]: entry({ fn: math_1.heaviside, minArgs: 1, maxArgs: 1, distElWise: true }),
+    hypot: entry({ fn: geometry_1.hypot, minArgs: 2, maxArgs: 2, distElWise: true }),
+    [constants_1.FACTORIAL]: entry({ fn: math_1.factorial, minArgs: 1, maxArgs: 1, distElWise: true }),
+    factorial: entry({ fn: math_1.factorial, minArgs: 1, maxArgs: 1, distElWise: true }),
+    [constants_1.DOUBLE_FACTORIAL]: entry({ fn: math_1.doubleFactorial, minArgs: 1, maxArgs: 1, distElWise: true }),
+    expand: entry({ fn: expand_1.expand, minArgs: 1, maxArgs: 1, distElWise: true }),
+    numeric: entry({
+        fn: evaluate_1.numeric,
+        minArgs: 1,
+        maxArgs: 2,
+        equationArgs: [0],
+        distElWise: false,
+        deferArguments: true,
+    }),
+    round: entry({ fn: math_1.round, minArgs: 1, maxArgs: 2, distElWise: true }),
+    sign: entry({ fn: math_1.sign, minArgs: 1, maxArgs: 1, distElWise: true }),
+    floor: entry({ fn: math_1.floor, minArgs: 1, maxArgs: 1, distElWise: true }),
+    ceil: entry({ fn: math_1.ceiling, minArgs: 1, maxArgs: 1, distElWise: true }),
+    ceiling: entry({ fn: math_1.ceiling, minArgs: 1, maxArgs: 1, distElWise: true }),
+    trunc: entry({ fn: trunc_1.trunc, minArgs: 1, maxArgs: 1, distElWise: true }),
+    mod: entry({ fn: math_1.mod, minArgs: 2, maxArgs: 2, distElWise: true }),
+    modinv: entry({ fn: math_1.modInv, minArgs: 2, maxArgs: 2, distElWise: true }),
+    parens: entry({ fn: math_1.parens, minArgs: 1, maxArgs: 1, distElWise: true }),
+    count: entry({ fn: utils_2.count, minArgs: 1, maxArgs: 1, distElWise: false }),
+    size: entry({ fn: utils_2.size, minArgs: 1, maxArgs: 1, distElWise: false }),
+    contains: entry({ fn: math_1.contains, minArgs: 2, maxArgs: 2, distElWise: false }),
+    max: entry({ fn: math_1.max, minArgs: 2, maxArgs: -1, distElWise: true }),
+    min: entry({ fn: math_1.min, minArgs: 2, maxArgs: -1, distElWise: true }),
+    // Complex
+    imagpart: entry({ fn: complex_1.imagPart, minArgs: 1, maxArgs: 1, distElWise: true }),
+    realpart: entry({ fn: complex_1.realPart, minArgs: 1, maxArgs: 1, distElWise: true }),
+    polarform: entry({ fn: complex_1.polarForm, minArgs: 1, maxArgs: 1, distElWise: true }),
+    rectform: entry({ fn: complex_1.rectForm, minArgs: 1, maxArgs: 1, distElWise: true }),
+    arg: entry({ fn: complex_1.arg, minArgs: 1, maxArgs: 1, distElWise: true }),
+    csgn: entry({ fn: complex_1.csgn, minArgs: 1, maxArgs: 1, distElWise: true }),
+    conjugate: entry({ fn: complex_1.conjugate, minArgs: 1, maxArgs: 1, distElWise: true }),
+    // Matrices and Vector
+    matrix: entry({ fn: math_1.matrix, minArgs: 1, maxArgs: -1, distElWise: false }),
+    imatrix: entry({ fn: utils_4.imatrix, minArgs: 1, maxArgs: 1, distElWise: false }),
+    determinant: entry({ fn: functions_1.determinant, minArgs: 1, maxArgs: 1, distElWise: false }),
+    transpose: entry({ fn: (M) => M.transpose(), minArgs: 1, maxArgs: 1, distElWise: false }),
+    augment: entry({ fn: (M, N) => M.augment(N), minArgs: 2, maxArgs: 2, distElWise: false }),
+    rref: entry({ fn: (M, prime) => M.rref(prime), minArgs: 1, maxArgs: 2, distElWise: false }),
+    nullspace: entry({ fn: functions_1.nullspace, minArgs: 1, maxArgs: 2, distElWise: false }),
+    dot: entry({ fn: functions_3.dot, minArgs: 2, maxArgs: 2, distElWise: false }),
+    cross: entry({ fn: functions_3.cross, minArgs: 2, maxArgs: 2, distElWise: false }),
+    // Polynomials
+    deg: entry({ fn: functions_2.deg, minArgs: 1, maxArgs: 2, distElWise: true }),
+    content: entry({ fn: functions_2.content, minArgs: 1, maxArgs: 1, distElWise: true }),
+    div: entry({ fn: functions_2.div, minArgs: 2, maxArgs: 2, distElWise: false }),
+    divide: entry({ fn: functions_2.divide, minArgs: 2, maxArgs: 2, distElWise: false }),
+    // Calculus
+    diff: entry({ fn: parserDiff, minArgs: 1, maxArgs: 3, equationArgs: [0], distElWise: true }),
+    integrate: entry({ fn: parserIntegrate, minArgs: 1, maxArgs: 2, equationArgs: [0], distElWise: true }),
+    limit: entry({ fn: parserLimit, minArgs: 3, maxArgs: 4, distElWise: true }),
+    laplace: entry({ fn: laplace_1.laplace, minArgs: 3, maxArgs: 3, distElWise: true }),
+    ilaplace: entry({ fn: ilaplace_1.ilaplace, minArgs: 3, maxArgs: 3, distElWise: true }),
+    sum: entry({ fn: math_1.sum, minArgs: 4, maxArgs: 4, distElWise: true }),
+    product: entry({ fn: math_1.product, minArgs: 4, maxArgs: 4, distElWise: true }),
+    defint: entry({ fn: math_1.defint, minArgs: 4, maxArgs: 4, distElWise: true }),
+    [constants_1.FRESNEL_S]: entry({ fn: fresnel_1.S, minArgs: 1, maxArgs: 1, distElWise: true }),
+    [constants_1.FRESNEL_C]: entry({ fn: fresnel_1.C, minArgs: 1, maxArgs: 1, distElWise: true }),
+    // Algebra
+    polyfactors: entry({ fn: factor_1.polyFactors, minArgs: 1, maxArgs: 1, distElWise: false }),
+    factor: entry({ fn: factor_1.factor, minArgs: 1, maxArgs: 1, distElWise: true }),
+    simplify: entry({ fn: simplify_1.simplify, minArgs: 1, maxArgs: 1, distElWise: true }),
+    partfrac: entry({ fn: partfrac_1.partfrac, minArgs: 1, maxArgs: 2, distElWise: true }),
+    gcd: entry({ fn: gcd_1.gcd, minArgs: 2, maxArgs: 2, distElWise: true }),
+    lcm: entry({ fn: gcd_1.lcm, minArgs: 2, maxArgs: 2, distElWise: true }),
+    groebner: entry({ fn: groebner_1.groebner, minArgs: 1, maxArgs: 2, distElWise: false }),
+    sqcomp: entry({ fn: parserSqcomp, minArgs: 1, maxArgs: 2, distElWise: true }),
+    // Solver
+    solve: entry({ fn: solve_1.solve, minArgs: 2, maxArgs: 2, equationArgs: [0], distElWise: false }),
+    solveeqs: entry({ fn: solveSystem_1.solveSystem, minArgs: 1, maxArgs: 1, distElWise: false }),
+    // Assumptions and Sets
+    assume: entry({ fn: assume_1.assuming, minArgs: 1, maxArgs: 1, distElWise: false }),
+    forget: entry({ fn: assume_1.forget, minArgs: 1, maxArgs: 1, distElWise: false }),
+    unassign: entry({ fn: scope_1.unassign, minArgs: 1, maxArgs: 1, distElWise: false, deferArguments: true }),
+    // Parser scripting
+    evaluate: entry({
+        fn: evaluate_1.evaluate,
+        minArgs: 1,
+        maxArgs: 3,
+        equationArgs: [0],
+        distElWise: false,
+        deferArguments: true,
+        usage: 'scripting',
+    }),
+    return: entry({
+        fn: controlFlow_1.RETURN,
+        minArgs: 1,
+        maxArgs: 1,
+        equationArgs: [0],
+        distElWise: false,
+        bracketlessStatement: true,
+        usage: 'scripting',
+    }),
+    break: entry({ fn: controlFlow_1.BREAK, minArgs: 0, maxArgs: 0, distElWise: false, usage: 'scripting' }),
+    continue: entry({ fn: controlFlow_1.CONTINUE, minArgs: 0, maxArgs: 0, distElWise: false, usage: 'scripting' }),
+    and: entry({ fn: controlFlow_1.AND, minArgs: 2, maxArgs: -1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+    or: entry({ fn: controlFlow_1.OR, minArgs: 2, maxArgs: -1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+    not: entry({ fn: controlFlow_1.NOT, minArgs: 1, maxArgs: 1, distElWise: false, usage: 'scripting' }),
+    xor: entry({ fn: controlFlow_1.XOR, minArgs: 2, maxArgs: -1, distElWise: false, usage: 'scripting' }),
+    iferror: entry({ fn: controlFlow_1.IFERROR, minArgs: 2, maxArgs: 2, distElWise: false, deferArguments: true, usage: 'scripting' }),
+    iserror: entry({ fn: controlFlow_1.ISERROR, minArgs: 1, maxArgs: 1, distElWise: false, deferArguments: true, usage: 'scripting' }),
+    if: entry({ fn: controlFlow_1.IF, minArgs: 2, maxArgs: 3, distElWise: false, deferArguments: true, usage: 'scripting' }),
+    while: entry({ fn: controlFlow_1.WHILE, minArgs: 2, maxArgs: 2, distElWise: false, deferArguments: true, usage: 'scripting' }),
+    for: entry({ fn: controlFlow_1.FOR, minArgs: 4, maxArgs: 4, distElWise: false, deferArguments: true, usage: 'scripting' }),
+    each: entry({ fn: parserEach, minArgs: 3, maxArgs: 3, distElWise: false, deferArguments: true, usage: 'scripting' }),
+    let: entry({
+        fn: scope_1.LET,
+        minArgs: 3,
+        maxArgs: -1,
+        distElWise: false,
+        deferArguments: true,
+        normalizeDeferredArguments: scope_1.normalizeLetArguments,
+        returnBoundary: true,
+        usage: 'scripting',
+    }),
+    block: entry({
+        fn: controlFlow_1.BLOCK,
+        minArgs: -1,
+        maxArgs: -1,
+        distElWise: false,
+        deferArguments: true,
+        returnBoundary: true,
+        usage: 'scripting',
+    }),
+    // Special
+    isprime: entry({ fn: utils_2.isprime, minArgs: 1, maxArgs: 1, distElWise: true }),
+    fib: entry({ fn: math_1.fibonacci, minArgs: 1, maxArgs: 1, distElWise: true }),
+    sinc: entry({ fn: math_1.sinc, minArgs: 1, maxArgs: 1, distElWise: true }),
+    Shi: entry({ fn: math_1.Shi, minArgs: 1, maxArgs: 1, distElWise: true }),
+    Si: entry({ fn: math_1.Si, minArgs: 1, maxArgs: 1, distElWise: true }),
+    Chi: entry({ fn: math_1.Chi, minArgs: 1, maxArgs: 1, distElWise: true }),
+    Ci: entry({ fn: math_1.Ci, minArgs: 1, maxArgs: 1, distElWise: true }),
+    Ei: entry({ fn: math_1.Ei, minArgs: 1, maxArgs: 1, distElWise: true }),
+    [constants_1.LI]: entry({ fn: math_1.Li, minArgs: 1, maxArgs: 1, distElWise: true }),
+};