nerdamer 1.1.13 → 2.0.0-rc.1

package/output/utils/debug.js

@@ -0,0 +1,295 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printRPN = exports.printTokens = void 0;
+exports.createTypesMap = createTypesMap;
+exports.inspectTokens = inspectTokens;
+exports.inspectExpressionData = inspectExpressionData;
+exports.inspectEntity = inspectEntity;
+exports.inspectParse = inspectParse;
+exports.inspectTermData = inspectTermData;
+exports.inspectPolynomialData = inspectPolynomialData;
+exports.printE = printE;
+exports.inspectExpression = inspectExpression;
+exports.inspectTerm = inspectTerm;
+exports.inspectPolynomial = inspectPolynomial;
+exports.hr = hr;
+exports.simpleSerialize = simpleSerialize;
+const Collection_1 = require("../core/classes/collection/Collection");
+const Dictionary_1 = require("../core/classes/dictionary/Dictionary");
+const Equation_1 = require("../core/classes/equation/Equation");
+const Expression_1 = require("../core/classes/expression/Expression");
+const Matrix_1 = require("../core/classes/matrix/Matrix");
+const Parser_1 = require("../core/classes/parser/Parser");
+const preprocess_1 = require("../core/classes/parser/preprocess");
+const Polynomial_1 = require("../core/classes/polynomial/Polynomial");
+const ValuesSet_1 = require("../core/classes/valuesSet/ValuesSet");
+const Vector_1 = require("../core/classes/vector/Vector");
+const Scope_1 = require("../core/common/classes/Scope");
+const dispatch_1 = require("../core/dispatch");
+function createTypesMap() {
+    const map = {};
+    for (const [type, value] of Object.entries(Expression_1.Expression.TYPES)) {
+        map[value] = type;
+    }
+    return map;
+}
+/** Converts a parser token scope to JSON-safe diagnostic data. */
+function inspectTokens(scope) {
+    const items = [];
+    for (const item of scope) {
+        let inspected;
+        if (Scope_1.Scope.isScope(item)) {
+            inspected = inspectTokens(item);
+        }
+        else {
+            inspected = {
+                kind: 'token',
+                value: item.value,
+                type: item.type ?? null,
+                position: item.position,
+                text: item.toString(),
+            };
+        }
+        items.push(inspected);
+    }
+    return {
+        kind: 'scope',
+        type: scope.type,
+        depth: scope.depth,
+        column: scope.column,
+        isOpen: scope.isOpen,
+        implicitMultiply: scope.implicitMultiply,
+        deferLHSResolution: scope.deferLHSResolution,
+        deferRHSResolution: scope.deferRHSResolution,
+        text: scope.text(),
+        typedText: scope.text(false),
+        items,
+    };
+}
+/** Converts an Expression tree to JSON-safe diagnostic data without changing it. */
+function inspectExpressionData(obj) {
+    const typesMap = createTypesMap();
+    let elements = null;
+    let args = null;
+    if (obj.elements) {
+        elements = {};
+        for (const [key, element] of Object.entries(obj.elements)) {
+            elements[key] = inspectExpressionData(element);
+        }
+    }
+    if (obj.args) {
+        args = obj.args.map(argument => inspectExpressionData(argument));
+    }
+    return {
+        kind: 'Expression',
+        type: obj.type,
+        typeName: typesMap[obj.type] ?? 'UNKNOWN',
+        dataType: obj.dataType,
+        text: obj.copy().text(),
+        value: obj.value,
+        name: obj.name ?? null,
+        precision: obj.precision ?? null,
+        deferred: obj.deferred,
+        multiplier: obj.multiplier ? obj.multiplier.text() : null,
+        power: obj.power ? inspectExpressionData(obj.power) : null,
+        base: obj.base ? inspectExpressionData(obj.base) : null,
+        elements,
+        args,
+    };
+}
+/** Converts any current parser entity to plain diagnostic data. */
+function inspectEntity(entity) {
+    let retval;
+    if (Expression_1.Expression.isExpression(entity)) {
+        retval = inspectExpressionData(entity);
+    }
+    else if (Equation_1.Equation.isEquation(entity)) {
+        retval = {
+            kind: 'Equation',
+            dataType: entity.dataType,
+            text: entity.copy().text(),
+            LHS: inspectExpressionData(entity.LHS),
+            RHS: inspectExpressionData(entity.RHS),
+        };
+    }
+    else if (Vector_1.Vector.isVector(entity)) {
+        retval = {
+            kind: 'Vector',
+            dataType: entity.dataType,
+            text: entity.copy().text(),
+            elements: entity.elements.map(element => inspectEntity(element)),
+        };
+    }
+    else if (Matrix_1.Matrix.isMatrix(entity)) {
+        retval = {
+            kind: 'Matrix',
+            dataType: entity.dataType,
+            text: entity.copy().text(),
+            elements: entity.elements.map(row => row.map(element => inspectExpressionData(element))),
+        };
+    }
+    else if (ValuesSet_1.ValuesSet.isValuesSet(entity)) {
+        retval = {
+            kind: 'ValuesSet',
+            dataType: entity.dataType,
+            text: entity.copy().text(),
+            elements: entity.elements.map(element => inspectEntity(element)),
+        };
+    }
+    else if (Dictionary_1.Dictionary.isDictionary(entity)) {
+        retval = {
+            kind: 'Dictionary',
+            dataType: entity.dataType,
+            text: entity.copy().text(),
+            entries: entity.entries().map(([key, value]) => ({
+                key,
+                value: inspectEntity(value),
+            })),
+        };
+    }
+    else if (Collection_1.Collection.isCollection(entity)) {
+        retval = {
+            kind: 'Collection',
+            dataType: entity.dataType,
+            text: entity.copy().text(),
+            elements: entity.getElements().map(element => inspectEntity(element)),
+        };
+    }
+    else {
+        throw new TypeError('Unsupported parser entity');
+    }
+    return retval;
+}
+/** Inspects one parser input using the same preprocessing as Parser.parse(). */
+function inspectParse(source, values) {
+    const normalizedSource = (0, preprocess_1.preprocess)(source, dispatch_1.mathFunctionRegistry);
+    const tokenScope = Parser_1.Parser.tokenize(normalizedSource);
+    const tokens = inspectTokens(tokenScope);
+    const rpn = inspectTokens(Parser_1.Parser.toRPN(tokenScope));
+    const result = inspectEntity(Parser_1.Parser.parse(source, values));
+    return {
+        source,
+        normalizedSource,
+        tokens,
+        rpn,
+        result,
+    };
+}
+/** Converts a polynomial Term to JSON-safe diagnostic data without touching its caches. */
+function inspectTermData(t) {
+    const multidegree = t.variables.map(variable => t.powers[variable] ?? 0);
+    const totalPower = multidegree.reduce((sum, power) => sum + power, 0);
+    return {
+        kind: 'Term',
+        text: t.copy().text(),
+        coefficient: inspectExpressionData(t.coeff),
+        powers: { ...t.powers },
+        multidegree,
+        totalPower,
+        variables: [...t.variables],
+    };
+}
+/** Converts a Polynomial to JSON-safe diagnostic data. */
+function inspectPolynomialData(p) {
+    return {
+        kind: 'Polynomial',
+        text: new Polynomial_1.Polynomial(p).text(),
+        expression: inspectExpressionData(p.expression),
+        ordering: p.ordering,
+        isMultivariate: p.isMultivariate,
+        variables: [...p.variables],
+        terms: p.terms.map(term => inspectTermData(term)),
+    };
+}
+// https://stackoverflow.com/questions/57802057/eslint-configuring-no-unused-vars-for-typescript
+function printE(obj) {
+    const output = [];
+    for (const x in obj) {
+        let str = String(obj[x]);
+        if (typeof obj === 'object') {
+            try {
+                // Try to get a better representation that [object Object]
+                str = JSON.stringify(obj[x]);
+            }
+            catch { }
+        }
+        output.push(`${x}: ${str}`);
+    }
+    console.log(output.join(', '));
+}
+;
+const printTokens = (tokens, valuesOnly = true) => {
+    console.log(tokens.text(valuesOnly));
+};
+exports.printTokens = printTokens;
+const printRPN = (str) => {
+    const source = (0, preprocess_1.preprocess)(str, dispatch_1.mathFunctionRegistry);
+    (0, exports.printTokens)(Parser_1.Parser.toRPN(Parser_1.Parser.tokenize(source)));
+};
+exports.printRPN = printRPN;
+function inspectExpression(obj, depth = 0) {
+    const tab = '\t'.repeat(depth);
+    const typesMap = createTypesMap();
+    let elementsStr = tab + '{\n';
+    if (obj.elements) {
+        const elements = obj.getElements();
+        for (const x in elements) {
+            elementsStr += inspectExpression(elements[x], depth + 1);
+        }
+        elementsStr += `\n        ${tab}}`;
+    }
+    else {
+        elementsStr = 'undefined';
+    }
+    let argsStr = tab + '[\n';
+    if (obj.args) {
+        const args = obj.getArguments();
+        for (const arg of args) {
+            argsStr += inspectExpression(arg, depth + 1);
+        }
+        argsStr += `\n        ${tab}]`;
+    }
+    else {
+        argsStr = 'undefined';
+    }
+    return `
+    ${tab}{
+    ${tab}    type: ${typesMap[obj.type]},
+    ${tab}    dataType: ${obj.dataType},
+    ${tab}    precision: ${obj.precision},
+    ${tab}    value: ${obj.value},
+    ${tab}    multiplier: ${obj.multiplier ? obj.multiplier?.text() : obj.multiplier},
+    ${tab}    power: ${obj.power ? obj.power?.text() : obj.power},
+    ${tab}    name: ${obj.name},
+    ${tab}    deferred: ${obj.deferred},
+    ${tab}    elements: ${elementsStr},
+    ${tab}    args: ${argsStr},
+    ${tab}}`;
+}
+function inspectTerm(t) {
+    return `<Term(${t.text()}) coeff: ${t.coeff}, mdg: ${t.getMultidegArray()}, total power: ${t.getTotalPower()}, vars: ${t.variables}>`;
+}
+function inspectPolynomial(p) {
+    let terms = '';
+    for (const t of p.terms) {
+        terms += `\t    ${inspectTerm(t)}\n`;
+    }
+    return `<Polynomial(${p.text()})
+        terms: 
+${terms}\tLM: ${p.LM()}
+        ordering: ${p.ordering}
+>`;
+}
+function hr(symbol = '_', length = 70) {
+    console.log(symbol.repeat(length));
+}
+function simpleSerialize(obj) {
+    let retval = '{';
+    for (const x in obj) {
+        retval += `${x}: ${obj[x]},`;
+    }
+    if (retval.at(-1) === ',') {
+        retval = retval.slice(0, -1);
+    }
+    return retval + '}';
+}

package/output/utils/decimal.d.ts

@@ -0,0 +1,3 @@
+import { Decimal } from 'decimal.js';
+export declare function gcd(a: Decimal, b: Decimal): Decimal;
+export declare function isEven(n: string | Decimal | number): boolean;

package/output/utils/decimal.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gcd = gcd;
+exports.isEven = isEven;
+const decimal_js_1 = require("decimal.js");
+function gcd(a, b) {
+    while (!b.equals(0)) {
+        const t = a;
+        a = b;
+        b = t.mod(b);
+    }
+    return a;
+}
+function isEven(n) {
+    return decimal_js_1.Decimal.mod(n, 2).eq(0);
+}

package/output/utils/numeric.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Generates a pair of numbers given a set of prime numbers
+ * @param factors The list of prime factors to be used to generate the pairs
+ * @param target The target number that the pairs must equal
+ * @returns
+ */
+export declare function factorPairs(factors: number[], target: number): number[][];
+/**
+ * Gets the largest factor pair given a set of prime factors and a target
+ * @param factors The list of prime factors to be used to generate the pairs
+ * @param target The target number that the pairs must equal
+ * @returns
+ */
+export declare function maxPair(factors: number[], target: number): number[];

package/output/utils/numeric.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.factorPairs = factorPairs;
+exports.maxPair = maxPair;
+/**
+ * Generates a pair of numbers given a set of prime numbers
+ * @param factors The list of prime factors to be used to generate the pairs
+ * @param target The target number that the pairs must equal
+ * @returns
+ */
+function factorPairs(factors, target) {
+    const products = new Set();
+    // Generate all subset products
+    function backtrack(index, currentProduct) {
+        if (index === factors.length) {
+            products.add(currentProduct);
+            return;
+        }
+        // Skip current number
+        backtrack(index + 1, currentProduct);
+        // Include current number
+        backtrack(index + 1, currentProduct * factors[index]);
+    }
+    backtrack(0, 1);
+    const result = [];
+    const seen = new Set();
+    for (const p of products) {
+        if (p > 0 && target % p === 0) {
+            const q = target / p;
+            const key = Math.min(p, q); // prevent mirrored duplicates
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push([Math.min(p, q), Math.max(p, q)]);
+            }
+        }
+    }
+    return result.sort((a, b) => a[0] - b[0]);
+}
+/**
+ * Gets the largest factor pair given a set of prime factors and a target
+ * @param factors The list of prime factors to be used to generate the pairs
+ * @param target The target number that the pairs must equal
+ * @returns
+ */
+function maxPair(factors, target) {
+    const pair = factorPairs(factors, target).at(-1);
+    if (!pair) {
+        return [1, target];
+    }
+    return pair;
+}

package/output/utils/object.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Get the first encountered element in an object
+ *
+ * @param obj Any object
+ * @returns The first element encountered
+ */
+export declare function anyObject<T>(obj: Record<string, T>): T | undefined;
+/**
+ * Converts an array to an object with the key specified as a callback.
+ *
+ * @param arr
+ * @param key
+ * @returns
+ */
+export declare function arrayToObject<T>(arr: T[], key: (k: T, i: number) => number | string): Record<string | number, T>;
+/**
+ * Generates a random object that can be used to evaluate a function
+ *
+ * @param vars
+ * @param min
+ * @param max
+ * @returns
+ */
+export declare function randomEvalObj(vars: string[], min?: number, max?: number): {
+    [variable: string]: number;
+};

package/output/utils/object.js

@@ -0,0 +1,56 @@
+"use strict";
+/**
+ * Get the first encountered element in an object
+ *
+ * @param obj Any object
+ * @returns The first element encountered
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anyObject = anyObject;
+exports.arrayToObject = arrayToObject;
+exports.randomEvalObj = randomEvalObj;
+const numeric_1 = require("../core/functions/numeric");
+function anyObject(obj) {
+    for (const x in obj) {
+        return obj[x];
+    }
+}
+/**
+ * Converts an array to an object with the key specified as a callback.
+ *
+ * @param arr
+ * @param key
+ * @returns
+ */
+function arrayToObject(arr, key) {
+    const obj = {};
+    for (let i = 0; i < arr.length; i++) {
+        const e = arr[i];
+        obj[key(e, i)] = e;
+    }
+    return obj;
+}
+/**
+ * Generates a random object that can be used to evaluate a function
+ *
+ * @param vars
+ * @param min
+ * @param max
+ * @returns
+ */
+function randomEvalObj(vars, min = 2, max) {
+    const evalObj = {};
+    max ??= (vars.length + 2) * 2;
+    // Avoid duplicate numbers
+    const values = [];
+    for (const v of vars) {
+        let randomInt = (0, numeric_1.getRandomInt)(min, max);
+        // Select a random number which hasn't been chosen already
+        while (values.includes(randomInt)) {
+            randomInt = (0, numeric_1.getRandomInt)(min, max);
+        }
+        values.push(randomInt);
+        evalObj[v] = randomInt;
+    }
+    return evalObj;
+}