nerdamer 1.1.13 → 2.0.0-rc.1

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

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contains = contains;
+exports.constantsFreeProduct = constantsFreeProduct;
+exports.splitProductFactors = splitProductFactors;
+const shortcuts_1 = require("./shortcuts");
+/**
+ * Similar to hasVariable but is extended to products
+ *
+ * @param x
+ * @param y
+ */
+function contains(x, y) {
+    // If it's an integer then it's always true
+    let retval = false;
+    // If y is a multiple of x's multiplier then return true
+    const m = x.getMultiplier().abs();
+    const n = y.getMultiplier().abs();
+    // The division can only occur if y's multiplier is an integer multiple of x's multiplier
+    if (m.isInteger() && n.isInteger() && m.gte(n)) {
+        // Multiples of the integers are a good match so we're done.
+        if (y.isNUM()) {
+            retval = true;
+        }
+        else if (x.isProduct()) {
+            // If it's a variable then just check if it has that variable
+            if (y.isVAR()) {
+                retval = x.hasVariable(y.value);
+            }
+            else if (y.isProduct()) {
+                // We check each variable granted that
+                // 1 - It's not under the denominator
+                // 2 - It's of type VAR
+                const variables = y.elementsArray();
+                for (let i = 0; i < variables.length; i++) {
+                    const v = variables[i];
+                    // We check of the above-mentioned conditions. If any of them are true do
+                    // nothing. Otherwise pass it.
+                    const p = v.getPower();
+                    if (v.isVAR() && x.hasVariable(v.value) && p.isInteger() && p.gt((0, shortcuts_1.zero)())) {
+                        retval = true;
+                    }
+                    // If any of the variables doesn't pass then we're done and exit.
+                    else {
+                        retval = false;
+                        break;
+                    }
+                }
+            }
+        }
+    }
+    return retval;
+} /**
+ * Removes the multiplier and constants wrt to a given variable
+ * @param expression
+ * @param wrtVariable
+ */
+function constantsFreeProduct(expression, wrtVariable) {
+    // Remove the multiplier
+    let constants = expression.getMultiplier(true);
+    expression = expression.toUnitMultiplier();
+    // Products are always power of one
+    // TODO: Move to helper called constantsFree
+    if (expression.isProduct() && expression.isLinear()) {
+        // Remove the constants
+        // e.g. a*(cos(x)+sin(x))
+        let constantFree = (0, shortcuts_1.one)();
+        expression.each(e => {
+            if (!e.hasVariable(wrtVariable)) {
+                constants = constants.times(e);
+            }
+            else {
+                constantFree = constantFree.times(e);
+            }
+            expression = constantFree;
+        });
+    }
+    return {
+        constants,
+        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
+ */
+function splitProductFactors(f, factors) {
+    // Only products need apply
+    if (!f.isProduct()) {
+        return [f];
+    }
+    factors ??= [];
+    f.each(e => {
+        // Check the exponent. If it has a integer multiplier > 1 then split
+        const p = e.getPower();
+        const pm = p.getMultiplier();
+        if (pm.isInteger() && pm.gt((0, shortcuts_1.one)())) {
+            const ps = p.toUnitMultiplier();
+            // Get the base
+            const base = e.toLinearAndUnitMultiplier();
+            for (let i = 0; i < Number(pm.numerator); i++) {
+                factors.push(base.pow(ps));
+            }
+        }
+        else if (e.isProduct()) {
+            splitProductFactors(e, factors);
+        }
+        else {
+            factors.push(e);
+        }
+    });
+    return factors;
+}

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

@@ -0,0 +1,35 @@
+import { Expression } from './Expression';
+export declare function zero(): Expression;
+export declare function quarter(): Expression;
+export declare function third(): Expression;
+export declare function half(): Expression;
+export declare function one(): Expression;
+export declare function minusOne(): Expression;
+export declare function two(): Expression;
+export declare function minusTwo(): Expression;
+export declare function three(): Expression;
+export declare function minusThree(): Expression;
+export declare function four(): Expression;
+export declare function five(): Expression;
+export declare function six(): Expression;
+export declare function seven(): Expression;
+export declare function eight(): Expression;
+export declare function sixteen(): Expression;
+export declare function twentySeven(): Expression;
+export declare function twoHundredFiftySix(): Expression;
+export declare function I(): Expression;
+export declare function all(): Expression;
+/**
+ * A convenience function for creating simple symbols reducing the reliance on strings
+ * @param args A series of string variables
+ * @returns An object of created symbols
+ *
+ * @example
+ * ```ts
+ * const { x, y } = symbols('x', 'y');
+ * cos(x.sq()).times(y);
+ *
+ * // Also available as nerdamer.symbols
+ * ```
+ */
+export declare function symbols(...args: string[]): Record<string, Expression>;

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zero = zero;
+exports.quarter = quarter;
+exports.third = third;
+exports.half = half;
+exports.one = one;
+exports.minusOne = minusOne;
+exports.two = two;
+exports.minusTwo = minusTwo;
+exports.three = three;
+exports.minusThree = minusThree;
+exports.four = four;
+exports.five = five;
+exports.six = six;
+exports.seven = seven;
+exports.eight = eight;
+exports.sixteen = sixteen;
+exports.twentySeven = twentySeven;
+exports.twoHundredFiftySix = twoHundredFiftySix;
+exports.I = I;
+exports.all = all;
+exports.symbols = symbols;
+const errors_1 = require("../../errors");
+const constants_1 = require("../parser/constants");
+const Expression_1 = require("./Expression");
+const CACHE = {};
+function getFromCacheOrCreate(value) {
+    if (CACHE[value] === undefined) {
+        const c = Expression_1.Expression.Number(value);
+        // Set the power and multiplier since this create problems
+        // later when it's requested because we'll be freezing this object
+        c.getMultiplier();
+        c.getPower();
+        Object.freeze(c);
+        CACHE[value] = c;
+    }
+    return CACHE[value];
+}
+function zero() {
+    return getFromCacheOrCreate('0');
+}
+function quarter() {
+    return getFromCacheOrCreate('1/4');
+}
+function third() {
+    return getFromCacheOrCreate('1/3');
+}
+function half() {
+    return getFromCacheOrCreate('1/2');
+}
+function one() {
+    return getFromCacheOrCreate('1');
+}
+function minusOne() {
+    return getFromCacheOrCreate('-1');
+}
+function two() {
+    return getFromCacheOrCreate('2');
+}
+function minusTwo() {
+    return getFromCacheOrCreate('-2');
+}
+function three() {
+    return getFromCacheOrCreate('3');
+}
+function minusThree() {
+    return getFromCacheOrCreate('-3');
+}
+function four() {
+    return getFromCacheOrCreate('4');
+}
+function five() {
+    return getFromCacheOrCreate('5');
+}
+function six() {
+    return getFromCacheOrCreate('6');
+}
+function seven() {
+    return getFromCacheOrCreate('7');
+}
+function eight() {
+    return getFromCacheOrCreate('8');
+}
+function sixteen() {
+    return getFromCacheOrCreate('16');
+}
+function twentySeven() {
+    return getFromCacheOrCreate('27');
+}
+function twoHundredFiftySix() {
+    return getFromCacheOrCreate('256');
+}
+function I() {
+    return Expression_1.Expression.Img();
+}
+function all() {
+    return Expression_1.Expression.Variable(constants_1.ALL_SYMBOL);
+}
+/**
+ * A convenience function for creating simple symbols reducing the reliance on strings
+ * @param args A series of string variables
+ * @returns An object of created symbols
+ *
+ * @example
+ * ```ts
+ * const { x, y } = symbols('x', 'y');
+ * cos(x.sq()).times(y);
+ *
+ * // Also available as nerdamer.symbols
+ * ```
+ */
+function symbols(...args) {
+    const created = {};
+    for (const x of args) {
+        // Must be a plain variable
+        const c = Expression_1.Expression.create(x);
+        // Trigger creation of multiplier and power.
+        c.getMultiplier();
+        c.getPower();
+        if (!c.isVAR()) {
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('plainVariableExpected'));
+        }
+        // Make it read-only
+        Object.freeze(c);
+        created[x] = c;
+    }
+    return created;
+}

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

@@ -0,0 +1,31 @@
+import type { Expression } from './Expression';
+/**
+ * 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[]; /**
+ * Collects all the variables in an expression
+ *
+ * @param x
+ * @param vars
+ * @param reserved Names excluded from free-variable collection.
+ * @returns
+ */
+export declare function variables(x: Expression, vars: string[] | undefined, reserved: readonly string[]): string[];
+/**
+ * Collects the functions in a symbolic expression
+ *
+ * @param x
+ * @param fns
+ * @returns
+ */
+export declare function functions(x: Expression, fns?: string[], getValues?: boolean): string[];
+export declare function hasFunction(x: Expression, name: string, deep?: boolean): boolean;
+export declare function hasVariable(x: Expression, variable: string): boolean; /**
+ * Loops through each elements and rebuilds a new expression
+ * @param x
+ * @param fn
+ * @returns
+ */
+export declare function forEveryElement(x: Expression, fn: (e: Expression) => Expression, isLeaf?: boolean): Expression;

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

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectVariablesSet = collectVariablesSet;
+exports.variables = variables;
+exports.functions = functions;
+exports.hasFunction = hasFunction;
+exports.hasVariable = hasVariable;
+exports.forEveryElement = forEveryElement;
+const shortcuts_1 = require("./shortcuts");
+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();
+} /**
+ * Collects all the variables in an expression
+ *
+ * @param x
+ * @param vars
+ * @param reserved Names excluded from free-variable collection.
+ * @returns
+ */
+function variables(x, vars, reserved) {
+    // Must be of type VAR, cannot be the imaginary unit or a reserved variable, and cannot have been encountered before
+    const condition = (x, vars) => {
+        return (x.isVAR() &&
+            !x.isI() &&
+            !vars.includes(x.value) &&
+            !reserved.includes(x.value));
+    };
+    const action = (x, vars) => {
+        vars.push(x.value);
+    };
+    return collect(x, condition, action, vars);
+}
+/**
+ * Collects the functions in a symbolic expression
+ *
+ * @param x
+ * @param fns
+ * @returns
+ */
+function functions(x, fns, getValues) {
+    // The name property is guaranteed on the FUN type.
+    const condition = (x, fns) => {
+        return x.isFunction() && !fns.includes(getValues === true ? x.value : x.name);
+    };
+    const action = (x, fns) => {
+        if (getValues === true) {
+            fns.push(x.value);
+        }
+        else if (x.isFunction()) {
+            fns.push(x.name);
+        }
+    };
+    return collect(x, condition, action, fns);
+}
+function hasFunction(x, name, deep = false) {
+    if (x.isFunction() && x.name === name) {
+        return true;
+    }
+    // Search the function arguments
+    if (deep && x.args) {
+        for (const e of x.args) {
+            if (hasFunction(e, name, deep)) {
+                return true;
+            }
+        }
+    }
+    // Search the sub-elements
+    if (x.elements) {
+        for (const e in x.elements) {
+            if (hasFunction(x.elements[e], name, deep)) {
+                return true;
+            }
+        }
+    }
+    // Search the power
+    if (deep && x.isEXP()) {
+        // Check x value. It's difficult to know if it's a variable
+        // so the best way is to parse and check.
+        // Creating a new instance seems like overkill
+        if (hasFunction(x.getBase(), name, deep)) {
+            return true;
+        }
+        // Check the power
+        if (hasFunction(x.getPower(), name, deep)) {
+            return true;
+        }
+    }
+    return false;
+}
+function hasVariable(x, variable) {
+    // Only VAR is a variable so we want its value.
+    if (x.isVAR() && x.value === variable) {
+        return true;
+    }
+    // Search the function arguments
+    if (x.args) {
+        for (const e of x.args) {
+            if (hasVariable(e, variable)) {
+                return true;
+            }
+        }
+    }
+    // Search the sub-elements
+    if (x.elements) {
+        const elements = x.getElements();
+        for (const e in elements) {
+            if (hasVariable(elements[e], variable)) {
+                return true;
+            }
+        }
+    }
+    // Search the power
+    if (x.isEXP()) {
+        // Check x value. It's difficult to know if it's a variable
+        // so the best way is to parse and check.
+        // TODO: See if x still makes sense. Creating a new instance seems like overkill
+        if (hasVariable(x.getBase(), variable)) {
+            return true;
+        }
+        // Check the power
+        if (hasVariable(x.getPower(), variable)) {
+            return true;
+        }
+    }
+    return false;
+} /**
+ * Loops through each elements and rebuilds a new expression
+ * @param x
+ * @param fn
+ * @returns
+ */
+function forEveryElement(x, fn, isLeaf = false) {
+    // There's nothing to iterate over for these types so done.
+    if (x.isNUM() || x.isVAR()) {
+        return x;
+    }
+    const m = x.getMultiplier();
+    let p = x.getPower();
+    // Call it on p if it's an EXP
+    if (x.isEXP()) {
+        p = forEveryElement(p, fn, true);
+    }
+    // Don't call it again if it was called from inside forEveryElement and trust that it was
+    // properly processed
+    const exp = fn(x.toLinearAndUnitMultiplier());
+    let retval;
+    if (exp.isFunction()) {
+        exp.args = exp.getArguments().map(e => {
+            if (isLeaf) {
+                return fn(e);
+            }
+            return forEveryElement(e, fn, true);
+        });
+        retval = exp;
+    }
+    else if (exp.isProduct()) {
+        retval = (0, shortcuts_1.one)();
+        for (let e of exp.elementsArray()) {
+            e = fn(e);
+            retval = retval.times(forEveryElement(e, fn, true));
+        }
+    }
+    else if (exp.isSum()) {
+        retval = (0, shortcuts_1.zero)();
+        for (let e of exp.elementsArray()) {
+            e = fn(e);
+            retval = retval.plus(forEveryElement(e, fn, true));
+        }
+    }
+    else {
+        retval = fn(exp);
+    }
+    return retval.pow(p).times(m);
+}

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

@@ -0,0 +1,25 @@
+import type { Expression } from './Expression';
+/**
+ * Checks if a function is a trig function
+ * @param f
+ * @returns
+ */
+export declare function isTrig(f: Expression): boolean;
+/**
+ * Checks if a function is a inverse trig function
+ * @param f
+ * @returns
+ */
+export declare function isInverseTrig(f: Expression): boolean;
+/**
+ * Checks if a function is a hyperbolic trig function
+ * @param f
+ * @returns
+ */
+export declare function isHyperbolicTrig(f: Expression): boolean;
+/**
+ * Checks if a function is a hyperbolic trig function
+ * @param f
+ * @returns
+ */
+export declare function isInverseHyperbolicTrig(f: Expression): boolean;

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isTrig = isTrig;
+exports.isInverseTrig = isInverseTrig;
+exports.isHyperbolicTrig = isHyperbolicTrig;
+exports.isInverseHyperbolicTrig = isInverseHyperbolicTrig;
+const constants_1 = require("../parser/constants");
+// Trig helpers
+/**
+ * Checks if a function is a trig function
+ * @param f
+ * @returns
+ */
+function isTrig(f) {
+    return f.isFunction() && constants_1.TRIG.includes(f.name);
+}
+/**
+ * Checks if a function is a inverse trig function
+ * @param f
+ * @returns
+ */
+function isInverseTrig(f) {
+    return f.isFunction() && constants_1.INVERSE_TRIG.includes(f.name);
+}
+/**
+ * Checks if a function is a hyperbolic trig function
+ * @param f
+ * @returns
+ */
+function isHyperbolicTrig(f) {
+    return f.isFunction() && constants_1.HYPERBOLIC_TRIG.includes(f.name);
+}
+/**
+ * Checks if a function is a hyperbolic trig function
+ * @param f
+ * @returns
+ */
+function isInverseHyperbolicTrig(f) {
+    return f.isFunction() && constants_1.INVERSE_HYPERBOLIC_TRIG.includes(f.name);
+}

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

@@ -0,0 +1,52 @@
+import { Expression } from './Expression';
+import type { OptionsObject } from '../parser/types';
+export type conditionType = (x: Expression, values: string[]) => boolean;
+export type actionType = (x: Expression, values: string[]) => void;
+type ExpressionTuplesObj = {
+    num: Expression[];
+    den: Expression[];
+    power?: ExpressionTuplesObj;
+    args?: ExpressionTuplesObj[];
+};
+export type termType = {
+    type: number;
+    num: Expression[];
+    den: Expression[];
+    name?: string;
+    power?: termType;
+    elements?: termType[];
+    args?: termType[];
+};
+/** Multiplies a series of Expressions into one product. */
+export declare function product(...args: Expression[]): Expression;
+/** Adds a series of Expressions into one sum. */
+export declare function sum(...args: Expression[]): Expression;
+/** Removes the power from an Expression. The original object is unchanged. */
+export declare function stripPower(x: Expression): Expression;
+/**
+ * Copies over all the properties of the provided symbolic essentially cloning it to x.
+ *
+ * @param sym
+ * @returns
+ */
+export declare function copyOver(src: Expression, target: Expression, options?: OptionsObject): Expression;
+/**
+ * This function converts the expression in a collection of arrays
+ *
+ * @param x
+ * @param arrayObj
+ * @returns
+ */
+export declare function toArrays(x: Expression, arrayObj?: ExpressionTuplesObj): ExpressionTuplesObj;
+/**
+ * Gets the max between two or more Expressions. Just know that if two variable arguments are provided,
+ * it will not be able to know with any certainty which is bigger so the first one will be returned.
+ *
+ * @param x
+ * @param args
+ * @returns
+ */
+export declare function largestPower(x: Expression, ...args: Expression[]): Expression;
+export declare function assertPlainVariableAndGetString(x: Expression): string;
+export declare function getNumericOrAssumedValue(x: Expression): Expression | undefined;
+export {};