nerdamer 1.1.13 → 2.0.0-rc.1

package/output/core/functions/rationalNormalization.d.ts

@@ -0,0 +1,11 @@
+import { Expression } from '../classes/expression/Expression';
+/**
+ * Rewrites exact ratios to a common denominator without invoking algebra-level
+ * factoring or simplification.
+ *
+ * @remarks
+ * Core comparison uses this normalization to determine whether an exact symbolic
+ * difference is zero. Algebra also reuses the same implementation for rational
+ * simplification, keeping the dependency direction from algebra to core.
+ */
+export declare function toCommonDenominator(x: Expression): Expression;

package/output/core/functions/rationalNormalization.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCommonDenominator = toCommonDenominator;
+const Expression_1 = require("../classes/expression/Expression");
+const shortcuts_1 = require("../classes/expression/shortcuts");
+/**
+ * Groups additive terms that already share the same symbolic denominator.
+ *
+ * This is part of core exact normalization rather than the higher-level algebra
+ * simplifier because symbolic comparison relies on it for zero/equality checks.
+ */
+function groupByDenominator(x) {
+    let retval = x;
+    if (x.isSum()) {
+        let nonRationals = (0, shortcuts_1.zero)();
+        const rationals = {};
+        x.each(e => {
+            const num = e.getNumerator();
+            const den = e.getDenominator();
+            // Numerator extraction is exact, so restore the term's decimal marker
+            // before regrouping it. Otherwise a decimal coefficient silently becomes
+            // an exact rational during common-denominator normalization.
+            if (e.getMultiplier().asDecimal) {
+                num.getMultiplier().asDecimal = true;
+            }
+            if (den.isOne()) {
+                nonRationals = nonRationals.plus(num);
+            }
+            else {
+                const key = den.text();
+                rationals[key] = rationals[key] ? rationals[key].plus(num) : num;
+            }
+        });
+        retval = nonRationals;
+        for (const denominator in rationals) {
+            retval = retval.plus(rationals[denominator].div(Expression_1.Expression.create(denominator)));
+        }
+        retval = retval.pow(x.getPower()).times(x.getMultiplier());
+    }
+    return retval;
+}
+/**
+ * Rewrites exact ratios to a common denominator without invoking algebra-level
+ * factoring or simplification.
+ *
+ * @remarks
+ * Core comparison uses this normalization to determine whether an exact symbolic
+ * difference is zero. Algebra also reuses the same implementation for rational
+ * simplification, keeping the dependency direction from algebra to core.
+ */
+function toCommonDenominator(x) {
+    let retval = x;
+    if (x.isProduct()) {
+        retval = Expression_1.Expression.fromRational(x.getMultiplier());
+        x.each(e => {
+            e = e.pow(x.getPower());
+            if (e.isSum()) {
+                retval = retval.times(toCommonDenominator(e));
+            }
+            else {
+                retval = retval.times(e);
+            }
+        });
+    }
+    else if (x.isSum()) {
+        x = groupByDenominator(x);
+        if (!x.isSum()) {
+            return x;
+        }
+        const p = x.getPower().abs();
+        const m = x.getMultiplier();
+        const terms = x.elementsArray();
+        let hasNonTrivialDenominator = false;
+        let hasSymbolicDenominator = false;
+        for (const e of terms) {
+            const den = e.getDenominator();
+            if (!den.isOne()) {
+                hasNonTrivialDenominator = true;
+                if (!den.isNUM()) {
+                    hasSymbolicDenominator = true;
+                }
+            }
+        }
+        if (!hasNonTrivialDenominator) {
+            return x;
+        }
+        if (!hasSymbolicDenominator && !x.isPolynomialLike()) {
+            return x;
+        }
+        let numerator = (0, shortcuts_1.zero)();
+        let denominator = (0, shortcuts_1.one)();
+        for (const e of terms) {
+            const normalizedTerm = toCommonDenominator(e);
+            const num = normalizedTerm.getNumerator();
+            const den = normalizedTerm.getDenominator();
+            // getNumerator() returns the exact rational numerator, so carry the
+            // original term's decimal intent onto that numerator before combining
+            // fractions. This keeps decimal contagion intact through the rewrite.
+            if (e.getMultiplier().asDecimal) {
+                num.getMultiplier().asDecimal = true;
+            }
+            numerator = numerator.times(den).plus(denominator.times(num));
+            denominator = denominator.times(den);
+        }
+        if (x.getPower().sign() === -1) {
+            [denominator, numerator] = [numerator, denominator];
+        }
+        retval = numerator.div(denominator);
+        if (!p.isOne()) {
+            retval = retval.pow(p);
+        }
+        if (!m.isOne()) {
+            retval = retval.times(Expression_1.Expression.fromRational(m));
+        }
+    }
+    return retval;
+}

package/output/core/functions/setFunction.d.ts

@@ -0,0 +1,19 @@
+import type { ExpressionFunction, JsFunction } from '../classes/parser/types';
+import type { RegisteredMathFunction } from '../dispatch';
+interface SetFunctionBaseParams {
+    name: string;
+    minArgs?: number;
+    maxArgs?: number;
+}
+export interface SetJSFunctionParams extends SetFunctionBaseParams {
+    type: 'js';
+    fn: JsFunction;
+}
+export interface SetSymbolicFunctionParams extends SetFunctionBaseParams {
+    type: 'symbolic';
+    fn: string | RegisteredMathFunction | ExpressionFunction;
+    argsOrder?: string[];
+}
+export type SetFunctionParams = SetJSFunctionParams | SetSymbolicFunctionParams;
+export declare function setFunction(params: SetFunctionParams): void;
+export {};

package/output/core/functions/setFunction.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setFunction = setFunction;
+const Expression_1 = require("../classes/expression/Expression");
+const functions_1 = require("../classes/parser/scripting/functions");
+const dispatch_1 = require("../dispatch");
+const errors_1 = require("../errors");
+/**
+ * This is essentially a wrapper around the user provided JS function. It checks each input
+ * to ensure that it can be converted to a number. If all inputs are numbers, then the
+ * function is called, otherwise a symbolic function is returned.
+ *
+ * @param name
+ * @param fn
+ * @returns
+ */
+function jsWrapper(name, fn) {
+    return (...expressions) => {
+        const args = [];
+        for (const e of expressions) {
+            if (e.isNUM()) {
+                args.push(Number(e.getMultiplier().toDecimal()));
+            }
+            else {
+                return Expression_1.Expression.toFunction(name, expressions);
+            }
+        }
+        return Expression_1.Expression.create(Number(fn(...args)));
+    };
+}
+function entry(minArgs, maxArgs, fn, maxPrecision) {
+    return {
+        minArgs,
+        maxArgs,
+        fn,
+        maxPrecision,
+        usage: 'notation',
+        level: 'user',
+    };
+}
+function setFunction(params) {
+    const existing = dispatch_1.mathFunctionRegistry[params.name];
+    if (existing?.level === 'system') {
+        throw new errors_1.AssignmentError((0, errors_1.message)('restrictedVariableName', { name: params.name }));
+    }
+    if (params.type === 'js') {
+        const name = params.name;
+        if (typeof params.fn !== 'function') {
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('setJSFunctionExpectsFunction'));
+        }
+        if (!params.minArgs || !params.maxArgs) {
+            throw new errors_1.UnexpectedInputError((0, errors_1.message)('functionRequiresMinAndMaxArgs'));
+        }
+        dispatch_1.mathFunctionRegistry[name] = entry(params.minArgs, params.maxArgs, jsWrapper(name, params.fn), 17);
+    }
+    else if (params.type === 'symbolic') {
+        // Check if the user provided a string
+        if (typeof params.fn === 'string') {
+            // Only parse the body when argument order must be inferred. Parsing a body with
+            // control flow should not execute that control flow during registration.
+            const args = params.argsOrder ?? Expression_1.Expression.create(params.fn).variables().sort();
+            dispatch_1.mathFunctionRegistry[params.name] = entry(
+            // If the user didn't provide a min and max arg number then default to the args length
+            params.minArgs ?? args.length, params.maxArgs ?? args.length, (0, functions_1.wrappedFunction)(params.fn, args));
+        }
+        // This one is the simplest one of them all. Just set the function and be done
+        else {
+            const name = params.name;
+            if (params.minArgs === undefined || params.maxArgs === undefined) {
+                throw new errors_1.UnexpectedInputError((0, errors_1.message)('functionRequiresMinAndMaxArgs'));
+            }
+            dispatch_1.mathFunctionRegistry[name] = entry(params.minArgs, params.maxArgs, params.fn);
+        }
+    }
+}

package/output/core/functions/string.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Converts a string from scientific notation form to decimal form
+ *
+ * @param str
+ * @returns
+ */
+export declare function scientificToDecimal(str: string): string;
+/**
+ * Splits at the decimal but ensures that array length is always 2
+ *
+ * @param str
+ * @returns
+ */
+export declare function decimalSplit(str: string): string[];
+/**
+ * A helper function to replace multiple occurrences in a string. Tag the replacement
+ * with a double curly.
+ * @example format('Hi. My name is {{name}}.', {name: 'John Doe'})
+ *
+ * @param str
+ * @param replacements
+ * @returns
+ */
+export declare function format(str: string, replacements: {
+    [replacement: string]: string;
+} | string[]): string;

package/output/core/functions/string.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scientificToDecimal = scientificToDecimal;
+exports.decimalSplit = decimalSplit;
+exports.format = format;
+/**
+ * Removes the minus sign from the beginning of the string
+ *
+ * @param str
+ * @returns an array with the first item as true if a minus
+ * was found and the string minus the minus sign.
+ */
+function stripSign(str) {
+    // Check if it has a minus sign
+    const hasMinus = str.charAt(0) === '-';
+    // Remove it if it does
+    if (hasMinus || str.charAt(0) === '+') {
+        str = str.substring(1);
+    }
+    return [hasMinus, str];
+}
+/**
+ * Converts a string from scientific notation form to decimal form
+ *
+ * @param str
+ * @returns
+ */
+function scientificToDecimal(str) {
+    let isNegative;
+    // Remove the sign by slicing the string
+    [isNegative, str] = stripSign(str);
+    // Split it into coefficient and exponent
+    const [c, e] = str.toLowerCase().split('e');
+    // Split the coefficient into the whole and decimal portion
+    // eslint-disable-next-line prefer-const
+    let [w, d] = c.split('.');
+    // Provide and empty sting for safety if in the form n(e)n
+    d = d || '';
+    // The total length of the string
+    const length = w.length + (d ? d.length : 0);
+    // The total string minus the dot
+    const numString = w + d;
+    // If it's small then we need to calculate the leading zeros
+    // The shift of the decimal place to the left
+    const dotLocation = w.length + Number(e);
+    // Is the dot needed or not
+    const dot = dotLocation === length ? '' : '.';
+    let value;
+    if (dotLocation <= 0) {
+        // Join the value but pad after the dot with zeroes
+        value = `0${dot}${'0'.repeat(Math.abs(dotLocation))}${numString}`;
+    }
+    else if (dotLocation > length) {
+        value = `${numString}${'0'.repeat(Math.abs(dotLocation - length))}`;
+    }
+    else {
+        value = `${numString.substring(0, dotLocation)}${dot}${numString.substring(dotLocation)}`;
+    }
+    return isNegative ? '-' + value : value;
+}
+/**
+ * Splits at the decimal but ensures that array length is always 2
+ *
+ * @param str
+ * @returns
+ */
+function decimalSplit(str) {
+    const parts = str.split('.');
+    if (parts.length > 2) {
+        throw new SyntaxError(`Invalid decimal value: ${str}`);
+    }
+    if (parts.length === 1) {
+        parts.push('');
+    }
+    return parts;
+}
+/**
+ * A helper function to replace multiple occurrences in a string. Tag the replacement
+ * with a double curly.
+ * @example format('Hi. My name is {{name}}.', {name: 'John Doe'})
+ *
+ * @param str
+ * @param replacements
+ * @returns
+ */
+function format(str, replacements) {
+    const replace = function (str, replacement, newValue) {
+        return str.replace(new RegExp(`{{${replacement}}}`, 'g'), newValue);
+    };
+    if (Array.isArray(replacements)) {
+        for (let i = 0; i < replacements.length; i++) {
+            str = replace(str, String(i), replacements[i]);
+        }
+    }
+    else {
+        for (const x in replacements) {
+            str = replace(str, x, replacements[x]);
+        }
+    }
+    return str;
+}

package/output/core/functions/subst.d.ts

@@ -0,0 +1,90 @@
+import { Expression } from '../classes/expression/Expression';
+import type { ExpressionInput } from '../types';
+/** Maps generated substitution symbols such as `u0` back to their original expressions. */
+export type SubstitutionMap = Record<string, Expression>;
+/** Result returned by {@link uSub}. */
+export type USubstitutionResult = [
+    expression: Expression,
+    substitutions: SubstitutionMap
+];
+/** @deprecated Use {@link SubstitutionMap}. */
+export type MapObjectType = SubstitutionMap;
+export declare function prodSubst(expression: Expression, value: Expression, withValue: Expression, includeNumeric?: boolean): Expression;
+/**
+ * Performs a substitution on a sum
+ *
+ * @param expression
+ * @param value
+ * @param withValue
+ * @returns
+ */
+export declare function sumSubst(expression: Expression, value: Expression, withValue: Expression, includeNumeric?: boolean): Expression;
+/**
+ * Replaces a value with another using the existing Expression tree.
+ *
+ * @param expression The expression being used to perform the substitution
+ * @param value The value currently in the expression
+ * @param withValue The value that the substitution is being replaced with
+ */
+export declare function subst(expression: ExpressionInput, value: ExpressionInput, withValue: ExpressionInput, includeNumeric?: boolean): Expression;
+export declare function getU(x: ExpressionInput, map?: MapObjectType): string;
+/**
+ * Replaces one repeated sub-expression with a generated `uN` symbol.
+ *
+ * The generated symbol is chosen so it does not collide with variables already present
+ * in the expression or substitution map. Pass the returned map to later calls when
+ * several substitutions should share one namespace, then use {@link uUnSub} to restore
+ * the original expressions.
+ *
+ * @param x - Expression in which the substitution will occur.
+ * @param value - Sub-expression to replace.
+ * @param map - Existing substitution map to extend.
+ * @returns The substituted expression and the updated substitution map.
+ *
+ * @example
+ * ```ts
+ * const [substituted, map] = uSub('cos(x)^2+cos(x)+1', 'cos(x)');
+ * substituted.text({ sort: true }); // "u0^2+u0+1"
+ * uUnSub(substituted, map).eq('cos(x)^2+cos(x)+1'); // true
+ * ```
+ */
+export declare function uSub(x: ExpressionInput, value: ExpressionInput, map?: SubstitutionMap): USubstitutionResult;
+/**
+ * Rewrites powers of one variable through a radical substitution without
+ * sending the replacement back through generic nested-power simplification.
+ * The caller supplies the substitution degree, so fractional powers become
+ * exact integer powers of the replacement variable when possible.
+ */
+export declare function rewriteRadicals(e: Expression, variable: string, newVar: Expression, n: bigint): Expression;
+export declare function subRadicals(x: Expression): [Expression, MapObjectType];
+/**
+ * Restores substitutions produced by {@link uSub}.
+ *
+ * @param expression - Expression containing generated substitution symbols.
+ * @param map - Map returned by one or more u-substitution calls.
+ * @returns The expression after restoring every mapped value.
+ */
+export declare function uUnSub(expression: Expression, map: SubstitutionMap): Expression;
+/**
+ * Performs a u-substitution of all the constants in the expression.
+ *
+ * @param expression
+ * @param map
+ * @returns
+ */
+export declare function uSubConstants(expression: Expression, map?: MapObjectType): [Expression, MapObjectType];
+/**
+ * Performs a u-substitution on all the functions in the expression
+ *
+ * @param expression
+ * @param map
+ * @returns
+ */
+export declare function uSubFN(expression: Expression, map?: MapObjectType): [Expression, MapObjectType];
+/**
+ * Performs a u-substitution on all the exponential functions in the expression
+ * @param expression
+ * @param map
+ * @returns
+ */
+export declare function uSubEXP(expression: Expression, map?: MapObjectType): [Expression, MapObjectType];