nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/classes/expression/analysis.d.ts

@@ -0,0 +1,25 @@
+import { CoeffObject } from './CoeffObject';
+import { Expression } from './Expression';
+/**
+ * Separates the variable and coefficient for the specified variable
+ *
+ * @param x
+ * @param variable
+ * @returns
+ */
+export declare function separateVar(x: Expression, variables: (string | Expression)[]): Expression[];
+/**
+ * Gets the coefficients wrt to a given variable
+ *
+ * @param wrt
+ */
+export declare function coeffs(x: Expression, variables: string[], coeffsObj?: CoeffObject): CoeffObject;
+export declare function getDenominator(x: Expression): Expression;
+export declare function getNumerator(x: Expression): Expression; /**
+ * Returns true fo polynomial with coefficients in Z or Q.
+ * @param x
+ * @returns
+ */
+export declare function isPolynomialLike(x: Expression): boolean;
+export declare function getVariable(x: Expression, variable: string): Expression;
+export declare function normalizeMultiplierDenominators(x: Expression): Expression;

package/output/core/classes/expression/analysis.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.separateVar = separateVar;
+exports.coeffs = coeffs;
+exports.getDenominator = getDenominator;
+exports.getNumerator = getNumerator;
+exports.isPolynomialLike = isPolynomialLike;
+exports.getVariable = getVariable;
+exports.normalizeMultiplierDenominators = normalizeMultiplierDenominators;
+const errors_1 = require("../../errors");
+const bigint_1 = require("../../functions/bigint/bigint");
+const expand_1 = require("../../functions/expand/expand");
+const CoeffObject_1 = require("./CoeffObject");
+const Expression_1 = require("./Expression");
+const shortcuts_1 = require("./shortcuts");
+const utils_1 = require("./utils");
+/**
+ * Separates the variable and coefficient for the specified variable
+ *
+ * @param x
+ * @param variable
+ * @returns
+ */
+function separateVar(x, variables) {
+    // Extract the value of the variable if a Expression was provided
+    const vars = variables.map(x => {
+        if (typeof x !== 'string') {
+            return x.value;
+        }
+        return x;
+    });
+    function isLike(x, vars) {
+        return vars.includes(x.value);
+    }
+    let retval;
+    // You can only separate in a product and not a sum. e.g. 3*a*x
+    if (x.isProduct()) {
+        const coeff = [Expression_1.Expression.fromRational(x.getMultiplier())];
+        const v = [];
+        x.each(e => {
+            // GRP should be separated as well so we have to perform an additional check.
+            if (isLike(e, vars)) {
+                v.push(e);
+            }
+            else {
+                coeff.push(e);
+            }
+        });
+        retval = [(0, utils_1.product)(...coeff), (0, utils_1.product)(...v) || (0, shortcuts_1.one)()];
+    }
+    // E.g. 3*x^2 or 5*(x^2+x) or 4*x^x
+    else if (isLike(x, vars)) {
+        retval = [Expression_1.Expression.fromRational(x.getMultiplier()), x.toUnitMultiplier()];
+    }
+    // e.g. 3*b or 6
+    else {
+        retval = [Expression_1.Expression.create(x), (0, shortcuts_1.one)()];
+    }
+    return retval;
+}
+/**
+ * Gets the coefficients wrt to a given variable
+ *
+ * @param wrt
+ */
+function coeffs(x, variables, coeffsObj) {
+    const cObj = coeffsObj || new CoeffObject_1.CoeffObject(variables);
+    // Complex sums are canonically stored as re + i*im. If the requested variables
+    // are inside im, treating i*im as a single coefficient leaves those variables
+    // buried inside the coefficient. Split the two components and collect them
+    // independently, then restore i on the imaginary coefficients.
+    if (x.isComplex() && !variables.includes(Expression_1.Expression.imaginary)) {
+        const realCoeffs = coeffs(x.realPart(), variables);
+        const imaginaryCoeffs = coeffs(x.imagPart(), variables);
+        realCoeffs.each((coeff, power) => cObj.add(power, coeff));
+        imaginaryCoeffs.each((coeff, power) => cObj.add(power, coeff.times(Expression_1.Expression.Img())));
+        return cObj;
+    }
+    // First sanitize the expression
+    if (x.isProduct()) {
+        let coefficient = (0, shortcuts_1.one)();
+        let product = Expression_1.Expression.fromRational(x.getMultiplier());
+        let hasCoefficientFactor = false;
+        for (const element of x.elementsArray()) {
+            if (element.isSum() && element.getPower().sign() < 0) {
+                const dependsOnVariable = variables.some(variable => element.hasVariable(variable));
+                if (dependsOnVariable) {
+                    throw new errors_1.PolynomialError((0, errors_1.message)('notAPolynomial'));
+                }
+                coefficient = coefficient.times(element);
+                hasCoefficientFactor = true;
+            }
+            else {
+                product = product.times(element);
+            }
+        }
+        if (hasCoefficientFactor) {
+            const productCoeffs = coeffs(product, variables);
+            productCoeffs.each((value, power) => {
+                cObj.add(power, coefficient.times(value));
+            });
+            return cObj;
+        }
+        x = product;
+    }
+    // Expand the expression
+    const f = (0, expand_1.expand)(x);
+    if (f.isSum()) {
+        // Loop through the expression and get the coefficient for each
+        f.each(e => {
+            coeffs(e, variables, cObj);
+        });
+    }
+    else {
+        // const [coeff, v] = x.separateVar(...variables);
+        const [coeff, v] = separateVar(x, variables);
+        // const p = v.getPower().text();
+        const powers = variables.map(x => v.getVariable(x).getPower().text());
+        // cObj[p] = cObj[p] ? cObj[p].plus(coeff) : coeff;
+        cObj.add(powers.join(','), coeff);
+    }
+    return cObj;
+}
+function getDenominator(x) {
+    let retval = Expression_1.Expression.Number(x.getMultiplier().denominator);
+    const isProduct = x.isProduct();
+    const sign = x.getPower().sign();
+    // Using sign === -1 is not a bug since the power gets distributed by default.
+    if (sign === -1) {
+        retval = retval.times(x.toUnitMultiplier().invert());
+    }
+    else if (isProduct && x.isLinear()) {
+        for (const element of x.elementsArray()) {
+            if (element.isProduct()) {
+                retval = retval.times(getDenominator(element));
+            }
+            else if (element.getPower().sign() < 0) {
+                retval = retval.times(element.invert());
+                // retval = retval.times(element.invert());
+            }
+        }
+    }
+    return retval;
+}
+function getNumerator(x) {
+    // Initialize with the value of the multiplier's numerator. e.g. (1/2)*x = 1*x as the numerator
+    let retval = Expression_1.Expression.Number(x.getMultiplier().numerator);
+    const isProduct = x.isProduct();
+    const sign = x.getPower().sign();
+    // If it's not a product and the sign is positive then we're done e.g. x, (1+x)^2, ...
+    if ((!isProduct && sign > 0) || (isProduct && sign > 0 && !x.isLinear())) {
+        retval = retval.times(x.toUnitMultiplier());
+    }
+    // Otherwise, we loop through the product
+    else if (isProduct && x.isLinear()) {
+        const elements = x.elementsArray();
+        for (const e of elements) {
+            const num = getNumerator(e);
+            retval = retval.times(num);
+        }
+    }
+    return retval;
+} /**
+ * Returns true fo polynomial with coefficients in Z or Q.
+ * @param x
+ * @returns
+ */
+function isPolynomialLike(x) {
+    const power = x.getPower();
+    // Instantly disqualify elements under the denominator, radicals, exponential functions, infinity, ...
+    if (!power.isInteger() || power.sign() === -1 || x.isEXP() || x.isFunction() || x.isInf()) {
+        return false;
+    }
+    // Check within nested sums and products
+    else if (x.isSum() || x.isProduct()) {
+        // Check the elements
+        for (const element of x.elementsArray()) {
+            if (!isPolynomialLike(element)) {
+                return false;
+            }
+        }
+    }
+    // Return true for all else x, x^2, etc
+    return true;
+}
+function getVariable(x, variable) {
+    if (x.value === variable) {
+        return x;
+    }
+    else if (x.isProduct()) {
+        const elements = x.getElements();
+        for (const x in elements) {
+            if (elements[x].value === variable) {
+                return elements[x];
+            }
+        }
+    }
+    return (0, shortcuts_1.zero)();
+} // Example 1/2*x+3/5*y+2/7*z
+// Returns 1/70 (35 x + 42 y + 20 z)
+function normalizeMultiplierDenominators(x) {
+    let retval;
+    if (x.isSum()) {
+        const distributed = x.distributeMultiplier();
+        const terms = distributed.elementsArray();
+        const denominators = [];
+        for (const term of terms) {
+            denominators.push(term.getMultiplier().denominator);
+        }
+        const denominator = (0, bigint_1.LCM)(...denominators);
+        const expression = distributed.times(denominator).distributeMultiplier();
+        retval = expression.div(denominator);
+    }
+    else {
+        retval = x;
+    }
+    return retval;
+}

package/output/core/classes/expression/collect.d.ts

@@ -0,0 +1,9 @@
+import type { Expression } from './Expression';
+import type { conditionType, actionType } from './utils';
+export declare function collect(x: Expression, condition: conditionType, action: actionType, values?: string[]): string[];
+/**
+ * Collects all variables from a set of expressions, sorted alphabetically.
+ * @param exprs The array of expression from which the variables will be collect
+ * @returns
+ */
+export declare function collectVariablesSet(exprs: Expression[]): string[];

package/output/core/classes/expression/collect.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collect = collect;
+exports.collectVariablesSet = collectVariablesSet;
+function collect(x, condition, action, values) {
+    values ??= [];
+    if (condition(x, values)) {
+        action(x, values);
+    }
+    // Apply it to function arguments
+    if (x.args) {
+        for (const e of x.args) {
+            collect(e, condition, action, values);
+        }
+    }
+    // Search the sub-elements
+    if (x.elements) {
+        for (const e in x.elements) {
+            collect(x.elements[e], condition, action, values);
+        }
+    }
+    // Search the power
+    if (x.isEXP()) {
+        // Check target value. It's difficult to know if it's a variable so the best way is to parse and check.
+        // The unfortunate consequence is that we create a reliance on Parser.parse but target is a very tricky
+        // issue to solve. Consider (x+1)^x. A link to the previous type can be created but then if it gets
+        // raised again (x+1)^x^x then we have two links in which case we're not searching the chain.
+        // Is it better to rely on parse? Or a reference to target class and introduce a `searchChain` method for instance.
+        collect(x.getBase(), condition, action, values);
+        // Check the power
+        collect(x.getPower(), condition, action, values);
+    }
+    return values;
+}
+/**
+ * Collects all variables from a set of expressions, sorted alphabetically.
+ * @param exprs The array of expression from which the variables will be collect
+ * @returns
+ */
+function collectVariablesSet(exprs) {
+    const varSet = new Set();
+    for (const expr of exprs) {
+        const v = expr.variables();
+        for (const name of v) {
+            varSet.add(name);
+        }
+    }
+    return Array.from(varSet).sort();
+}

package/output/core/classes/expression/format.d.ts

@@ -0,0 +1,45 @@
+import type { TextOptions } from '../parser/types';
+import type { Expression } from './Expression';
+type ExpressionSortFunction = (a: Expression, b: Expression) => number;
+type ExpressionTextOptions = TextOptions & {
+    internalAccessor?: boolean;
+};
+/**
+ * Formats the multiplier string for string output.
+ * The multiplier string can be blank, include an *, or be formatted as a decimal or fraction.
+ *
+ * @param x
+ * @param options
+ * @returns
+ */
+export declare function formatMultiplierString(x: Expression, options?: ExpressionTextOptions): string;
+/**
+ * The power string can be blank, include a ^, or be formatted as a decimal or fraction.
+ * Since it can be fraction or an expression, it will also determine if brackets are needed.
+ *
+ * @param x
+ * @param options
+ * @param powerOperator
+ * @returns
+ */
+export declare function formatPowerString(x: Expression, options: ExpressionTextOptions | undefined, powerOperator: string): string;
+/**
+ * Formats an expression using the current formatting policy supplied by Expression.
+ *
+ * @param x
+ * @param options
+ * @param asId
+ * @param powerOperator
+ * @param sortFunction
+ * @returns
+ */
+export declare function toText(x: Expression, options: ExpressionTextOptions | undefined, asId: boolean | undefined, powerOperator: string, sortFunction: ExpressionSortFunction): string;
+export declare function formatExpressionString(x: Expression, options: ExpressionTextOptions | undefined, sortFunction: ExpressionSortFunction): string;
+/**
+ * Converts to capital letter e.g. 1=A, 2=B, ..., 100=CV
+ *
+ * @param n
+ * @returns
+ */
+export declare function convertToTitle(n: number): string;
+export {};

package/output/core/classes/expression/format.js

@@ -0,0 +1,217 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatMultiplierString = formatMultiplierString;
+exports.formatPowerString = formatPowerString;
+exports.toText = toText;
+exports.formatExpressionString = formatExpressionString;
+exports.convertToTitle = convertToTitle;
+const Settings_1 = require("../../Settings");
+const constants_1 = require("../parser/constants");
+const constants_2 = require("../parser/constants");
+const { NUM, FUN, VAR, INF, GRP, EXP, PRD, SUM } = constants_2.EXPRESSION_TYPES;
+/**
+ * Formats the multiplier string for string output.
+ * The multiplier string can be blank, include an *, or be formatted as a decimal or fraction.
+ *
+ * @param x
+ * @param options
+ * @returns
+ */
+function formatMultiplierString(x, options) {
+    let retval = '';
+    const m = x.getMultiplier();
+    const mString = m.text(options);
+    if (mString !== '1' && mString !== '1.0') {
+        retval = mString;
+        if (!m.isInteger() && !(m.asDecimal || options?.decimal)) {
+            retval = `(${retval})`;
+        }
+        // Don't show the minus one as -1* but just -
+        // When wrapPow is set, keep -1* to avoid unary minus before **
+        if (retval === '-1' && !options?.wrapPow) {
+            retval = '-';
+        }
+        else {
+            retval += '*';
+        }
+    }
+    return retval;
+}
+/**
+ * The power string can be blank, include a ^, or be formatted as a decimal or fraction.
+ * Since it can be fraction or an expression, it will also determine if brackets are needed.
+ *
+ * @param x
+ * @param options
+ * @param powerOperator
+ * @returns
+ */
+function formatPowerString(x, options, powerOperator) {
+    let retval = '';
+    const power = x.getPower();
+    const powerString = power.text(options);
+    if (powerString !== '1' && powerString !== '1.0') {
+        retval = powerString;
+        // Wrap fractions in brackets
+        if (power.dataType === constants_1.RATIONAL && !power.isInteger()) {
+            retval = `(${retval})`;
+        }
+        else {
+            const power = x.getPower();
+            let needsBrackets = false;
+            if (power.type === SUM || power.type === PRD) {
+                needsBrackets = true;
+            }
+            else if (x.type === EXP) {
+                if (power.isNUM() && !power.isInteger()) {
+                    needsBrackets = true;
+                }
+                else if (!power.isNUM() && !power.getMultiplier().isOne()) {
+                    needsBrackets = true;
+                }
+            }
+            if (needsBrackets || retval.includes('/')) {
+                retval = `(${retval})`;
+            }
+        }
+        if (options?.wrapPow && !retval.startsWith('(')) {
+            retval = `(${retval})`;
+        }
+        retval = `${powerOperator}${retval}`;
+    }
+    return retval;
+}
+/**
+ * Formats an expression using the current formatting policy supplied by Expression.
+ *
+ * @param x
+ * @param options
+ * @param asId
+ * @param powerOperator
+ * @param sortFunction
+ * @returns
+ */
+function toText(x, options, asId, powerOperator, sortFunction) {
+    options = { ...{ precision: x.precision }, ...options };
+    let retval = '';
+    if (x.type === NUM) {
+        retval = x.getMultiplier().text(options);
+    }
+    else {
+        // Get the multiplier but don't add it for the top level. Only
+        // format sub-elements
+        const multiplier = asId && !x.elements ? '' : formatMultiplierString(x, options);
+        const power = formatPowerString(x, options, powerOperator);
+        let value;
+        switch (x.type) {
+            case VAR:
+            case INF:
+                if (options?.wrapPow && power) {
+                    retval = `${multiplier}(${x.value})`;
+                }
+                else {
+                    retval = `${multiplier}${x.value}`;
+                }
+                break;
+            case FUN: {
+                // Symbolic access is stored as an ordinary function node so it can participate
+                // in Expression logic without allowing Vector or Matrix objects into args.
+                if (x.name === constants_1.SYMBOLIC_ACCESSOR) {
+                    const args = x.getArguments();
+                    if (options?.internalAccessor) {
+                        // Evaluation needs a parseable form that cannot be confused with
+                        // implicit multiplication when the target type is still unknown.
+                        retval = `${multiplier}${constants_1.SYMBOLIC_ACCESSOR}(${args
+                            .map(argument => argument.text(options))
+                            .join(', ')})`;
+                    }
+                    else {
+                        const target = args[0];
+                        const indices = args.slice(1);
+                        retval = `${multiplier}${target.text(options)}[${indices
+                            .map(index => index.text(options))
+                            .join(', ')}]`;
+                    }
+                }
+                else {
+                    // TODO: See Expression.toFunction for possible refactoring.
+                    retval = `${multiplier}${x.name || ''}(${x
+                        .getArguments()
+                        .map(x => x.text(options))
+                        .join(', ')})`;
+                }
+                break;
+            }
+            case GRP:
+            case SUM: {
+                value = formatExpressionString(x, options, sortFunction);
+                value = multiplier || power ? `(${value})` : value;
+                // The value has already been calculated when the values were added
+                retval = `${multiplier}${value}`;
+                break;
+            }
+            case PRD: {
+                value = formatExpressionString(x, options, sortFunction);
+                value = power ? `(${value})` : value;
+                retval = `${multiplier}${value}`;
+                break;
+            }
+            case EXP: {
+                const arg = x.getBase();
+                const p = arg.getPower();
+                value = toText(arg, options, undefined, powerOperator, sortFunction);
+                // The following cases get brackets.
+                // 1 - (x+1)^x
+                // 2 - (-x)^x
+                // 3 - (2/3)^x
+                // 4 - (x^x)^x
+                if (options?.wrapPow ||
+                    arg.elements ||
+                    value.startsWith('-') ||
+                    value.includes('/') ||
+                    !(p.isOne() || p.isZero())) {
+                    value = `(${value})`;
+                }
+                retval = `${multiplier}${value}`;
+                break;
+            }
+        }
+        retval += power;
+    }
+    return retval.replace(/\+-/g, '-');
+}
+// export function toTeX(x: Expression, options?: ExpressionTextOptions) {
+// }
+function formatExpressionString(x, options, sortFunction) {
+    const glue = x.type === PRD ? '*' : '+';
+    const elements = Object.values(x.getElements());
+    if (Settings_1.Settings.SORT_TERMS || options?.sort) {
+        elements.sort(sortFunction);
+    }
+    return elements
+        .map(e => {
+        let value = e.text(options);
+        // Wrap it in brackets for certain conditions
+        if (x.type === PRD && e.isSum()) {
+            value = `(${value})`;
+        }
+        return value;
+    })
+        .join(glue)
+        .replace('+-', '-');
+}
+/**
+ * Converts to capital letter e.g. 1=A, 2=B, ..., 100=CV
+ *
+ * @param n
+ * @returns
+ */
+function convertToTitle(n) {
+    let result = '';
+    while (n > 0) {
+        n--;
+        result = String.fromCharCode(65 + (n % 26)) + result;
+        n = Math.floor(n / 26);
+    }
+    return result;
+}

package/output/core/classes/expression/products.d.ts

@@ -0,0 +1,23 @@
+import type { Expression } from './Expression';
+/**
+ * Similar to hasVariable but is extended to products
+ *
+ * @param x
+ * @param y
+ */
+export declare function contains(x: Expression, y: Expression): boolean; /**
+ * Removes the multiplier and constants wrt to a given variable
+ * @param expression
+ * @param wrtVariable
+ */
+export declare function constantsFreeProduct(expression: Expression, wrtVariable: string): {
+    constants: Expression;
+    expression: Expression;
+};
+/**
+ * Splits a product into its factors e.g. a^2*b^3 will return [a, a, b, b, b]
+ * @param f
+ * @param factors
+ * @returns
+ */
+export declare function splitProductFactors(f: Expression, factors?: Expression[]): Expression[];