nerdamer 1.1.13 → 2.0.0-rc.1

package/output/api/core.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Core Nerdamer object model and shared public types.
+ *
+ * Import from `nerdamer/core` when working directly with Nerdamer values rather
+ * than through the callable compatibility root.
+ */
+export { Equation } from '../core/classes/equation/Equation';
+export { CoeffObject } from '../core/classes/expression/CoeffObject';
+export { Expression } from '../core/classes/expression/Expression';
+export type { ElementsSortType } from '../core/classes/expression/Expression';
+export { symbols } from '../core/classes/expression/shortcuts';
+export type { JsFunction, OptionValue, OptionsObject, ParserConstants, ParserValuesObject, TextOptions, } from '../core/classes/parser/types';
+export { Rational } from '../core/classes/rational/Rational';
+export { Converter } from '../core/converters/Converter';
+export { AssignmentError, DimensionError, DivisionByZeroError, MathError, MissingReferenceError, NaNError, NotImplementedError, OperatorError, ParserError, ParserSyntaxError, PolynomialError, UndefinedError, UnexpectedDataType, UnexpectedInputError, UnexpectedTokenError, UnsupportedOperationError, ZeroToZeroPowerError, } from '../core/errors';
+export { build as buildFunction } from '../core/functions/build';
+export type { ExpressionInput, NerdamerInput, ParserEntity, StructuredEntityType, } from '../core/types';

package/output/api/core.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFunction = exports.ZeroToZeroPowerError = exports.UnsupportedOperationError = exports.UnexpectedTokenError = exports.UnexpectedInputError = exports.UnexpectedDataType = exports.UndefinedError = exports.PolynomialError = exports.ParserSyntaxError = exports.ParserError = exports.OperatorError = exports.NotImplementedError = exports.NaNError = exports.MissingReferenceError = exports.MathError = exports.DivisionByZeroError = exports.DimensionError = exports.AssignmentError = exports.Converter = exports.Rational = exports.symbols = exports.Expression = exports.CoeffObject = exports.Equation = void 0;
+/**
+ * Core Nerdamer object model and shared public types.
+ *
+ * Import from `nerdamer/core` when working directly with Nerdamer values rather
+ * than through the callable compatibility root.
+ */
+var Equation_1 = require("../core/classes/equation/Equation");
+Object.defineProperty(exports, "Equation", { enumerable: true, get: function () { return Equation_1.Equation; } });
+var CoeffObject_1 = require("../core/classes/expression/CoeffObject");
+Object.defineProperty(exports, "CoeffObject", { enumerable: true, get: function () { return CoeffObject_1.CoeffObject; } });
+var Expression_1 = require("../core/classes/expression/Expression");
+Object.defineProperty(exports, "Expression", { enumerable: true, get: function () { return Expression_1.Expression; } });
+var shortcuts_1 = require("../core/classes/expression/shortcuts");
+Object.defineProperty(exports, "symbols", { enumerable: true, get: function () { return shortcuts_1.symbols; } });
+var Rational_1 = require("../core/classes/rational/Rational");
+Object.defineProperty(exports, "Rational", { enumerable: true, get: function () { return Rational_1.Rational; } });
+var Converter_1 = require("../core/converters/Converter");
+Object.defineProperty(exports, "Converter", { enumerable: true, get: function () { return Converter_1.Converter; } });
+var errors_1 = require("../core/errors");
+Object.defineProperty(exports, "AssignmentError", { enumerable: true, get: function () { return errors_1.AssignmentError; } });
+Object.defineProperty(exports, "DimensionError", { enumerable: true, get: function () { return errors_1.DimensionError; } });
+Object.defineProperty(exports, "DivisionByZeroError", { enumerable: true, get: function () { return errors_1.DivisionByZeroError; } });
+Object.defineProperty(exports, "MathError", { enumerable: true, get: function () { return errors_1.MathError; } });
+Object.defineProperty(exports, "MissingReferenceError", { enumerable: true, get: function () { return errors_1.MissingReferenceError; } });
+Object.defineProperty(exports, "NaNError", { enumerable: true, get: function () { return errors_1.NaNError; } });
+Object.defineProperty(exports, "NotImplementedError", { enumerable: true, get: function () { return errors_1.NotImplementedError; } });
+Object.defineProperty(exports, "OperatorError", { enumerable: true, get: function () { return errors_1.OperatorError; } });
+Object.defineProperty(exports, "ParserError", { enumerable: true, get: function () { return errors_1.ParserError; } });
+Object.defineProperty(exports, "ParserSyntaxError", { enumerable: true, get: function () { return errors_1.ParserSyntaxError; } });
+Object.defineProperty(exports, "PolynomialError", { enumerable: true, get: function () { return errors_1.PolynomialError; } });
+Object.defineProperty(exports, "UndefinedError", { enumerable: true, get: function () { return errors_1.UndefinedError; } });
+Object.defineProperty(exports, "UnexpectedDataType", { enumerable: true, get: function () { return errors_1.UnexpectedDataType; } });
+Object.defineProperty(exports, "UnexpectedInputError", { enumerable: true, get: function () { return errors_1.UnexpectedInputError; } });
+Object.defineProperty(exports, "UnexpectedTokenError", { enumerable: true, get: function () { return errors_1.UnexpectedTokenError; } });
+Object.defineProperty(exports, "UnsupportedOperationError", { enumerable: true, get: function () { return errors_1.UnsupportedOperationError; } });
+Object.defineProperty(exports, "ZeroToZeroPowerError", { enumerable: true, get: function () { return errors_1.ZeroToZeroPowerError; } });
+var build_1 = require("../core/functions/build");
+Object.defineProperty(exports, "buildFunction", { enumerable: true, get: function () { return build_1.build; } });

package/output/api/debug.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Contributor-facing diagnostic inspection helpers.
+ *
+ * @remarks
+ * This module exposes plain-data views of Nerdamer parser and expression internals for
+ * debugging tools, issue reports, and visual inspectors. The shapes reflect Nerdamer's
+ * implementation and may change between releases; they are not part of the mathematical
+ * compatibility surface provided by the ordinary package APIs.
+ *
+ * Import these helpers from `nerdamer/debug`. Loading this subpath does not add them to
+ * the browser UMD bundle or the root `nerdamer` callable.
+ *
+ * @module debug
+ */
+export { inspectEntity, inspectExpressionData as inspectExpression, inspectParse, inspectPolynomialData as inspectPolynomial, inspectTermData as inspectTerm, } from '../utils/debug';
+export type { DebugCollection, DebugDictionary, DebugDictionaryEntry, DebugEntity, DebugEquation, DebugExpression, DebugMatrix, DebugPolynomial, DebugScope, DebugScopeItem, DebugTerm, DebugToken, DebugValuesSet, DebugVector, ParseInspection, } from '../utils/debug';

package/output/api/debug.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inspectTerm = exports.inspectPolynomial = exports.inspectParse = exports.inspectExpression = exports.inspectEntity = void 0;
+/**
+ * Contributor-facing diagnostic inspection helpers.
+ *
+ * @remarks
+ * This module exposes plain-data views of Nerdamer parser and expression internals for
+ * debugging tools, issue reports, and visual inspectors. The shapes reflect Nerdamer's
+ * implementation and may change between releases; they are not part of the mathematical
+ * compatibility surface provided by the ordinary package APIs.
+ *
+ * Import these helpers from `nerdamer/debug`. Loading this subpath does not add them to
+ * the browser UMD bundle or the root `nerdamer` callable.
+ *
+ * @module debug
+ */
+var debug_1 = require("../utils/debug");
+Object.defineProperty(exports, "inspectEntity", { enumerable: true, get: function () { return debug_1.inspectEntity; } });
+Object.defineProperty(exports, "inspectExpression", { enumerable: true, get: function () { return debug_1.inspectExpressionData; } });
+Object.defineProperty(exports, "inspectParse", { enumerable: true, get: function () { return debug_1.inspectParse; } });
+Object.defineProperty(exports, "inspectPolynomial", { enumerable: true, get: function () { return debug_1.inspectPolynomialData; } });
+Object.defineProperty(exports, "inspectTerm", { enumerable: true, get: function () { return debug_1.inspectTermData; } });

package/output/api/parser.d.ts

@@ -0,0 +1,85 @@
+import type { ParserConstants, ParserValuesObject } from '../core/classes/parser/types';
+import type { SettingsType } from '../core/Settings';
+import type { ExpressionInput, ParserEntity } from '../core/types';
+type BooleanSettingName = {
+    [K in keyof SettingsType]: SettingsType[K] extends boolean ? K : never;
+}[keyof SettingsType];
+/**
+ * Supported high-level parser surface.
+ *
+ * Tokenization, RPN conversion, and parser-stack machinery remain internal
+ * implementation details even though Nerdamer itself uses them across modules.
+ */
+export interface ParserAPI {
+    /** Creates another parser facade backed by the shared parser configuration. */
+    create(): ParserAPI;
+    /**
+     * Parses and evaluates Nerdamer notation with optional substitutions.
+     * @param str - Nerdamer notation or expression-compatible input.
+     * @param values - Values substituted by name while parsing.
+     */
+    evaluate(str: string, values?: ParserValuesObject): ParserEntity;
+    /**
+     * Returns one shared parser setting with the value type associated with that setting.
+     */
+    get<K extends keyof SettingsType>(setting: K): SettingsType[K];
+    /** Returns the symbol currently used for the imaginary unit. */
+    getI(): string;
+    /** Returns the active Decimal precision. */
+    getPrecision(): number;
+    /**
+     * Parses Nerdamer notation with optional substitutions.
+     * @param str - Nerdamer notation or expression-compatible input.
+     * @param values - Values substituted by name while parsing.
+     */
+    parse(str: ExpressionInput, values?: ParserValuesObject): ParserEntity;
+    /**
+     * Temporarily changes one Boolean parser setting while a callback runs.
+     * @param setting - Boolean setting name to change.
+     * @param value - Temporary value for that setting.
+     * @param callback - Work to perform before restoring the previous setting.
+     */
+    scopedBlock<K extends BooleanSettingName>(setting: K, value: SettingsType[K], callback: () => ParserEntity): ParserEntity;
+    /**
+     * Changes one shared parser setting and returns the parser for chaining.
+     * @param setting - Supported parser setting name.
+     * @param value - Value associated with that setting.
+     */
+    set<K extends keyof SettingsType>(setting: K, value: SettingsType[K]): ParserAPI;
+    /**
+     * Changes several supported parser settings and returns the parser for chaining.
+     * @param settings - Partial set of supported parser settings.
+     */
+    set(settings: Partial<SettingsType>): ParserAPI;
+    /**
+     * Registers or removes parser constants.
+     * @param constants - Constant names mapped to values or deletion markers.
+     */
+    setConstants(constants: ParserConstants): void;
+    /**
+     * Changes the symbol used for the imaginary unit.
+     * @param variable - New imaginary-unit symbol.
+     */
+    setI(variable: string): ParserAPI;
+    /**
+     * Alias for {@link ParserAPI.setI}.
+     * @param variable - New imaginary-unit symbol.
+     */
+    setImaginary(variable: string): ParserAPI;
+    /**
+     * Changes the Decimal precision used by numerical calculations.
+     * @param precision - Significant decimal digits to retain.
+     */
+    setPrecision(precision: number): void;
+}
+/**
+ * Shared parser exposed through the supported high-level interface.
+ *
+ * The implementation accepts a broader compatibility settings bag; this facade exposes
+ * only the named settings defined by {@link SettingsType}.
+ */
+export declare const Parser: ParserAPI;
+export type { JsFunction, Operation, OptionValue, OptionsObject, ParserConstants, ParserValuesObject, PostFixFunction, PreFixFunction, } from '../core/classes/parser/types';
+export type { BinaryArithmeticOperation, ComparisonOperation, Operator, OperatorAction, OperatorDefinition, } from '../core/common/common';
+export type { Language } from '../core/errors';
+export type { SettingsType } from '../core/Settings';

package/output/api/parser.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+/**
+ * Supported high-level parser APIs and parser configuration types.
+ *
+ * @module parser
+ */
+const Parser_1 = require("../core/classes/parser/Parser");
+/**
+ * Shared parser exposed through the supported high-level interface.
+ *
+ * The implementation accepts a broader compatibility settings bag; this facade exposes
+ * only the named settings defined by {@link SettingsType}.
+ */
+exports.Parser = Parser_1.Parser;

package/output/api/solve.d.ts

@@ -0,0 +1,10 @@
+export type { FunctionSolverOptions, Root } from '../solve/classes/FunctionSolver';
+/** Public symbolic and polynomial solver APIs. */
+export { MultivariateSolver } from '../solve/classes/MultivariateSolver';
+export type { MultivariateSolverOptions } from '../solve/classes/MultivariateSolver';
+export { PolynomialSolver } from '../solve/classes/PolynomialSolver';
+export { SolutionSet } from '../solve/classes/SolutionSet';
+export type { SolutionForm, SolutionsType } from '../solve/classes/SolutionSet';
+export { SymbolicSolver } from '../solve/classes/SymbolicSolver';
+export { solve } from '../solve/solve';
+export { solveSystem } from '../solve/solveSystem';

package/output/api/solve.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveSystem = exports.solve = exports.SymbolicSolver = exports.SolutionSet = exports.PolynomialSolver = exports.MultivariateSolver = void 0;
+/** Public symbolic and polynomial solver APIs. */
+var MultivariateSolver_1 = require("../solve/classes/MultivariateSolver");
+Object.defineProperty(exports, "MultivariateSolver", { enumerable: true, get: function () { return MultivariateSolver_1.MultivariateSolver; } });
+var PolynomialSolver_1 = require("../solve/classes/PolynomialSolver");
+Object.defineProperty(exports, "PolynomialSolver", { enumerable: true, get: function () { return PolynomialSolver_1.PolynomialSolver; } });
+var SolutionSet_1 = require("../solve/classes/SolutionSet");
+Object.defineProperty(exports, "SolutionSet", { enumerable: true, get: function () { return SolutionSet_1.SolutionSet; } });
+var SymbolicSolver_1 = require("../solve/classes/SymbolicSolver");
+Object.defineProperty(exports, "SymbolicSolver", { enumerable: true, get: function () { return SymbolicSolver_1.SymbolicSolver; } });
+var solve_1 = require("../solve/solve");
+Object.defineProperty(exports, "solve", { enumerable: true, get: function () { return solve_1.solve; } });
+var solveSystem_1 = require("../solve/solveSystem");
+Object.defineProperty(exports, "solveSystem", { enumerable: true, get: function () { return solveSystem_1.solveSystem; } });

package/output/api/structures.d.ts

@@ -0,0 +1,10 @@
+/** Public structured-value and finite-set APIs. */
+export { Collection } from '../core/classes/collection/Collection';
+export { Dictionary } from '../core/classes/dictionary/Dictionary';
+export { determinant, nullspace } from '../core/classes/matrix/functions';
+export { Matrix } from '../core/classes/matrix/Matrix';
+export { imatrix } from '../core/classes/matrix/utils';
+export { ValuesSet } from '../core/classes/valuesSet/ValuesSet';
+export { cross, dot } from '../core/classes/vector/functions';
+export { Vector } from '../core/classes/vector/Vector';
+export type { StructuredEntityType } from '../core/types';

package/output/api/structures.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Vector = exports.dot = exports.cross = exports.ValuesSet = exports.imatrix = exports.Matrix = exports.nullspace = exports.determinant = exports.Dictionary = exports.Collection = void 0;
+/** Public structured-value and finite-set APIs. */
+var Collection_1 = require("../core/classes/collection/Collection");
+Object.defineProperty(exports, "Collection", { enumerable: true, get: function () { return Collection_1.Collection; } });
+var Dictionary_1 = require("../core/classes/dictionary/Dictionary");
+Object.defineProperty(exports, "Dictionary", { enumerable: true, get: function () { return Dictionary_1.Dictionary; } });
+var functions_1 = require("../core/classes/matrix/functions");
+Object.defineProperty(exports, "determinant", { enumerable: true, get: function () { return functions_1.determinant; } });
+Object.defineProperty(exports, "nullspace", { enumerable: true, get: function () { return functions_1.nullspace; } });
+var Matrix_1 = require("../core/classes/matrix/Matrix");
+Object.defineProperty(exports, "Matrix", { enumerable: true, get: function () { return Matrix_1.Matrix; } });
+var utils_1 = require("../core/classes/matrix/utils");
+Object.defineProperty(exports, "imatrix", { enumerable: true, get: function () { return utils_1.imatrix; } });
+var ValuesSet_1 = require("../core/classes/valuesSet/ValuesSet");
+Object.defineProperty(exports, "ValuesSet", { enumerable: true, get: function () { return ValuesSet_1.ValuesSet; } });
+var functions_2 = require("../core/classes/vector/functions");
+Object.defineProperty(exports, "cross", { enumerable: true, get: function () { return functions_2.cross; } });
+Object.defineProperty(exports, "dot", { enumerable: true, get: function () { return functions_2.dot; } });
+var Vector_1 = require("../core/classes/vector/Vector");
+Object.defineProperty(exports, "Vector", { enumerable: true, get: function () { return Vector_1.Vector; } });

package/output/calculus/derivative/diff.d.ts

@@ -0,0 +1,30 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Differentiates an expression symbolically.
+ *
+ * The chain, product, sum, and power rules are applied recursively, together
+ * with the built-in derivative table for recognized functions. An omitted
+ * variable is inferred as the first variable in the expression. Existing
+ * Expression input is reused during normalization.
+ *
+ * @remarks
+ * `n` requests a repeated derivative. A non-integer order, a non-variable
+ * differentiation target, or an unsupported derivative is preserved as an
+ * unevaluated `diff(...)` expression. Constants and expressions independent of
+ * the selected variable differentiate to zero.
+ *
+ * @param x - Expression to differentiate.
+ * @param variable - Variable with respect to which the derivative is taken.
+ * @param n - Positive integer derivative order. Defaults to the first derivative.
+ * @returns The symbolic derivative, or an unevaluated `diff(...)` call when the
+ * requested operation cannot be resolved.
+ * @throws {@link core!UnsupportedOperationError} If `variable` is numeric.
+ *
+ * @example
+ * ```ts
+ * diff('sin(x^2)', 'x').text();
+ * diff('x^4', 'x', 2).text();
+ * ```
+ */
+export declare function diff(x: ExpressionInput, variable?: ExpressionInput, n?: Expression | number): Expression;

package/output/calculus/derivative/diff.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diff = diff;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const shortcuts_1 = require("../../core/classes/expression/shortcuts");
+const constants_1 = require("../../core/classes/parser/constants");
+const helpers_1 = require("../../core/classes/parser/helpers");
+const errors_1 = require("../../core/errors");
+const math_1 = require("../../math/math");
+/**
+ * Applies the product rule to an expression
+ *
+ * @param expression
+ * @param variable
+ * @returns
+ */
+function productRule(expression, variable) {
+    //grab all the symbols within the CB symbol
+    const elements = expression.elementsArray();
+    let result = (0, shortcuts_1.zero)();
+    //loop over all the symbols
+    for (let i = 0; i < elements.length; i++) {
+        let df = diff(elements[i], variable);
+        for (let j = 0; j < elements.length; j++) {
+            //skip the symbol of which we just pulled the derivative
+            if (i !== j) {
+                //multiply out the remaining symbols
+                df = df.times(elements[j]);
+            }
+        }
+        //add the derivative to the result
+        result = result.plus(df);
+    }
+    return result; //done
+}
+/**
+ * Differentiates an expression symbolically.
+ *
+ * The chain, product, sum, and power rules are applied recursively, together
+ * with the built-in derivative table for recognized functions. An omitted
+ * variable is inferred as the first variable in the expression. Existing
+ * Expression input is reused during normalization.
+ *
+ * @remarks
+ * `n` requests a repeated derivative. A non-integer order, a non-variable
+ * differentiation target, or an unsupported derivative is preserved as an
+ * unevaluated `diff(...)` expression. Constants and expressions independent of
+ * the selected variable differentiate to zero.
+ *
+ * @param x - Expression to differentiate.
+ * @param variable - Variable with respect to which the derivative is taken.
+ * @param n - Positive integer derivative order. Defaults to the first derivative.
+ * @returns The symbolic derivative, or an unevaluated `diff(...)` call when the
+ * requested operation cannot be resolved.
+ * @throws {@link core!UnsupportedOperationError} If `variable` is numeric.
+ *
+ * @example
+ * ```ts
+ * diff('sin(x^2)', 'x').text();
+ * diff('x^4', 'x', 2).text();
+ * ```
+ */
+function diff(x, variable, n) {
+    x = Expression_1.Expression.create(x);
+    const variables = x.variables();
+    // Set the variable if none was provided
+    variable ??= Expression_1.Expression.Variable(variables[0]);
+    variable = Expression_1.Expression.create(variable);
+    const nth = typeof n === 'number' ? Expression_1.Expression.create(n) : n;
+    // If the variable is a number then complain
+    if (variable?.isNUM()) {
+        throw new errors_1.UnsupportedOperationError((0, errors_1.message)('unsupportedOperation'));
+    }
+    let retval;
+    if (variables.length === 0 || !x.hasVariable(variable.value) || x.isConstant()) {
+        retval = (0, shortcuts_1.zero)();
+    }
+    // If the variable is not of type VAR or nth is not an integer then return it untouched until either or both are resolved
+    else if ((variable && !variable.isVAR()) || (nth && !nth.isInteger())) {
+        retval = Expression_1.Expression.toFunction(constants_1.DIFF, [x, variable, nth]);
+    }
+    else if (x.isEXP()) {
+        // Apply rule a^x*(d/dx x*log(a))
+        const a = (0, math_1.log)(x.getBase());
+        const p = x.getPower();
+        const dx = diff(a.times(p), variable);
+        retval = x.times(dx);
+    }
+    // If the expression doesn't have a variable or if it's a constant then we're done
+    else {
+        // Reduce the nth call of the derivative
+        const n = nth ? Number(nth) - 1 : 0;
+        // Pull the derivate of the outside. At this point we've already performed all the required checks.
+        const m = x.getMultiplier().times(x.getPower());
+        const p = x.getPower().minus('1');
+        const f = Expression_1.Expression.create(x.value);
+        const fp = f.pow(p).times(m);
+        // Pull the derivative of the inside
+        if (f.isVAR()) {
+            retval = (0, shortcuts_1.one)();
+        }
+        else if (f.isSum()) {
+            let sum = (0, shortcuts_1.zero)();
+            f.elementsArray().forEach(e => {
+                sum = sum.plus(diff(e, variable));
+            });
+            retval = sum;
+        }
+        else if (f.isProduct()) {
+            retval = productRule(f, variable);
+        }
+        else if (f.isFunction()) {
+            const x = f.getArguments()[0];
+            const m = f.getMultiplier();
+            switch (f.name) {
+                case constants_1.LOG:
+                    retval = (0, helpers_1._)(`(${m})/(${x})`);
+                    break;
+                case constants_1.COS:
+                    retval = (0, helpers_1._)(`-sin(${x})`);
+                    break;
+                case constants_1.SIN:
+                    retval = (0, helpers_1._)(`cos(${x})`);
+                    break;
+                case constants_1.TAN:
+                    retval = (0, helpers_1._)(`sec(${x})^2`);
+                    break;
+                case constants_1.SEC:
+                    retval = (0, helpers_1._)(`tan(${x})*sec(${x})`);
+                    break;
+                case constants_1.CSC:
+                    retval = (0, helpers_1._)(`-cot(${x})*csc(${x})`);
+                    break;
+                case constants_1.COT:
+                    retval = (0, helpers_1._)(`-csc(${x})^2`);
+                    break;
+                case constants_1.ACOS:
+                    retval = (0, helpers_1._)(`-1/sqrt(1-(${x})^2)`);
+                    break;
+                case constants_1.ASIN:
+                    retval = (0, helpers_1._)(`1/sqrt(1-(${x})^2)`);
+                    break;
+                case constants_1.ATAN:
+                    retval = (0, helpers_1._)(`1/(1+(${x})^2)`);
+                    break;
+                case constants_1.ASEC:
+                    retval = (0, helpers_1._)(`1/(sqrt(1-1/(${x})^2)*(${x})^2)`);
+                    break;
+                case constants_1.ACSC:
+                    retval = (0, helpers_1._)(`-1/(sqrt(1-1/(${x})^2)*(${x})^2)`);
+                    break;
+                case constants_1.ACOT:
+                    retval = (0, helpers_1._)(`-1/(1+(${x})^2)`);
+                    break;
+                case constants_1.COSH:
+                    retval = (0, helpers_1._)(`sinh(${x})`);
+                    break;
+                case constants_1.SINH:
+                    retval = (0, helpers_1._)(`cosh(${x})`);
+                    break;
+                case constants_1.TANH:
+                    retval = (0, helpers_1._)(`sech(${x})^2`);
+                    break;
+                case constants_1.SECH:
+                    retval = (0, helpers_1._)(`-sech(${x})*tanh(${x})`);
+                    break;
+                case constants_1.CSCH:
+                    retval = (0, helpers_1._)(`-coth(${x})*csch(${x})`);
+                    break;
+                case constants_1.COTH:
+                    retval = (0, helpers_1._)(`-csch(${x})^2`);
+                    break;
+                case constants_1.ASINH:
+                    retval = (0, helpers_1._)(`1/sqrt(1+(${x})^2)`);
+                    break;
+                case constants_1.ACOSH:
+                    retval = (0, helpers_1._)(`1/(sqrt(-1+(${x}))*sqrt(1+(${x})))`);
+                    break;
+                case constants_1.ATANH:
+                    retval = (0, helpers_1._)(`1/(1-(${x})^2)`);
+                    break;
+                case constants_1.ASECH:
+                    retval = (0, helpers_1._)(`-1/(sqrt(-1+1/(${x}))*sqrt(1+1/(${x}))*(${x})^2)`);
+                    break;
+                case constants_1.ACSCH:
+                    retval = (0, helpers_1._)(`-1/(sqrt(1+1/(${x})^2)*(${x})^2)`);
+                    break;
+                case constants_1.ACOTH:
+                    retval = (0, helpers_1._)(`1/(1-(${x})^2)`);
+                    break;
+                case constants_1.ABS:
+                    // d/dx abs(u) = sign(u) * u'
+                    retval = (0, helpers_1._)(`sign(${x})`);
+                    break;
+                case constants_1.CI:
+                    retval = (0, helpers_1._)(`cos(${x})/${x}`);
+                    break;
+                case constants_1.CHI:
+                    retval = (0, helpers_1._)(`cosh(${x})/${x}`);
+                    break;
+                case constants_1.SI:
+                    retval = (0, helpers_1._)(`sin(${x})/${x}`);
+                    break;
+                case constants_1.SHI:
+                    retval = (0, helpers_1._)(`sinh(${x})/${x}`);
+                    break;
+                case constants_1.EI:
+                    retval = (0, helpers_1._)(`e^(${x})/${x}`);
+                    break;
+                case constants_1.LI:
+                    retval = (0, helpers_1._)(`1/${constants_1.LOG}(${x})`);
+                    break;
+                case constants_1.ERF:
+                    retval = (0, helpers_1._)(`(2*e^(-(${x})^2))/sqrt(pi)`);
+                    break;
+                case constants_1.SGN:
+                    retval = (0, shortcuts_1.zero)();
+                    break;
+                // Missing: S, Si, Shi, Ci, Chi, Ei, Li, erf, atan2, sinc, heaviside
+                // case '':
+                //     retval = _(``);
+                //     break;
+            }
+            // Multiply times the derivative of the inside
+            if (retval) {
+                retval = retval.times(diff(x, variable));
+            }
+        }
+        if (retval) {
+            retval = retval.times(fp);
+        }
+        // Pull the nth -1 derivative if that was requested
+        if (n > 0 && retval) {
+            retval = diff(retval, variable, Expression_1.Expression.Number(n));
+        }
+    }
+    return retval || Expression_1.Expression.toFunction(constants_1.DIFF, [x, variable, nth]);
+}

package/output/calculus/fresnel.d.ts

@@ -0,0 +1,16 @@
+import { Expression } from '../core/classes/expression/Expression';
+import type { ExpressionInput } from '../core/types';
+/**
+ * Computes the normalized Fresnel sine integral
+ * `S(x) = integral(sin(pi*t^2/2), t, 0, x)`.
+ *
+ * Numeric real arguments are evaluated numerically. Symbolic arguments remain as `S(x)`.
+ */
+export declare function S(x: ExpressionInput): Expression;
+/**
+ * Computes the normalized Fresnel cosine integral
+ * `C(x) = integral(cos(pi*t^2/2), t, 0, x)`.
+ *
+ * Numeric real arguments are evaluated numerically. Symbolic arguments remain as `C(x)`.
+ */
+export declare function C(x: ExpressionInput): Expression;

package/output/calculus/fresnel.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.S = S;
+exports.C = C;
+const Expression_1 = require("../core/classes/expression/Expression");
+const constants_1 = require("../core/classes/parser/constants");
+const fresnelNumeric_1 = require("../core/functions/fresnelNumeric");
+/** Evaluates a Fresnel integral numerically when the argument can be resolved to a real number. */
+function fresnel(x, name) {
+    const argument = Expression_1.Expression.create(x);
+    const evaluated = argument.isNUM() ? argument : argument.evaluate();
+    let retval;
+    if (evaluated.isNUM()) {
+        const value = Number(evaluated.getMultiplier().toDecimal());
+        retval = Expression_1.Expression.create(name === constants_1.FRESNEL_S ? (0, fresnelNumeric_1.fresnelS)(value) : (0, fresnelNumeric_1.fresnelC)(value));
+    }
+    else {
+        retval = Expression_1.Expression.toFunction(name, [argument]);
+    }
+    return retval;
+}
+/**
+ * Computes the normalized Fresnel sine integral
+ * `S(x) = integral(sin(pi*t^2/2), t, 0, x)`.
+ *
+ * Numeric real arguments are evaluated numerically. Symbolic arguments remain as `S(x)`.
+ */
+function S(x) {
+    return fresnel(x, constants_1.FRESNEL_S);
+}
+/**
+ * Computes the normalized Fresnel cosine integral
+ * `C(x) = integral(cos(pi*t^2/2), t, 0, x)`.
+ *
+ * Numeric real arguments are evaluated numerically. Symbolic arguments remain as `C(x)`.
+ */
+function C(x) {
+    return fresnel(x, constants_1.FRESNEL_C);
+}

package/output/calculus/integrate/byParts.d.ts

@@ -0,0 +1,18 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Attempts integration by parts for a product with two variable-dependent factors.
+ *
+ * LIATE priority selects `u`; independent multipliers are preserved separately.
+ * Category-specific progress checks and a dedicated recursion bound reject
+ * cyclic or increasingly complex decompositions.
+ *
+ * @param x - Product integrand.
+ * @param v - Integration variable.
+ * @param integrate - Recursive integration strategy supplied by the caller.
+ * @param depth - Current outer integration depth.
+ * @param ibpDepth - Current integration-by-parts depth.
+ * @returns An antiderivative when the transformation makes progress, otherwise
+ * `undefined` so another strategy can run.
+ */
+export declare function tryIntegrationByParts(x: Expression, v: string, integrate: (f: ExpressionInput, dx: ExpressionInput, depth: number) => Expression, depth?: number, ibpDepth?: number): Expression | undefined;