nerdamer 1.1.13 → 2.0.0-rc.1

package/output/index.d.ts

@@ -0,0 +1,339 @@
+import { sqcomp } from './algebra/utils';
+import { Assumption } from './core/classes/assumption/Assumption';
+import { Collection } from './core/classes/collection/Collection';
+import { Dictionary } from './core/classes/dictionary/Dictionary';
+import { Equation } from './core/classes/equation/Equation';
+import { Expression } from './core/classes/expression/Expression';
+import { Matrix } from './core/classes/matrix/Matrix';
+import { Parser } from './core/classes/parser/Parser';
+import { div as polynomialDiv, divide as polynomialDivide } from './core/classes/polynomial/functions';
+import { Polynomial } from './core/classes/polynomial/Polynomial';
+import { Rational } from './core/classes/rational/Rational';
+import { ValuesSet } from './core/classes/valuesSet/ValuesSet';
+import { Vector } from './core/classes/vector/Vector';
+import { Converter } from './core/converters/Converter';
+import { build } from './core/functions/build';
+import { imagPart, polarForm, realPart, rectForm } from './core/functions/complex';
+import { ceiling, dirac, doubleFactorial, fibonacci } from './math/math';
+import { isprime } from './math/utils';
+import { SolutionSet } from './solve/classes/SolutionSet';
+import type { OptionsObject, ParserConstants, ParserValuesObject, TextOptions } from './core/classes/parser/types';
+import type { ExpressionInput, ParserEntity } from './core/types';
+export type TeXOptions = OptionsObject | 'decimal' | 'decimals';
+export type { CompleteSquareResult } from './algebra/utils';
+export type { SubstitutionMap, USubstitutionResult, } from './core/functions/subst';
+export type { TextOptions };
+/** Scalar-only methods exposed by the full package on parsed results. */
+interface ScalarApi {
+    /**
+     * Compiles this value to a native JavaScript-number function when the parsed result
+     * is an Expression.
+     *
+     * Structured parser results expose this method so values returned by `nerdamer(...)`
+     * have one consistent TypeScript surface, but they cannot be compiled as scalar
+     * functions and throw {@link core!UnexpectedDataType} when called.
+     *
+     * @param argsArray - Optional variable names in positional call order.
+     * @returns A JavaScript-number function compiled from the scalar expression.
+     */
+    buildFunction(argsArray?: string[]): (...args: number[]) => number;
+}
+/** Methods supplied by the full package as chainable instance operations. */
+interface ChainableApi<T> extends ScalarApi {
+    diff(variable?: ExpressionInput, n?: Expression | number): T;
+    expand(): T;
+    factor(): T;
+    integrate(variable?: ExpressionInput): T;
+    numeric(precision?: ExpressionInput): T;
+    simplify(): T;
+    subst(value: ExpressionInput, withValue: ExpressionInput): T;
+}
+declare module './core/classes/expression/Expression' {
+    interface Expression {
+        /**
+         * Differentiates this expression symbolically.
+         *
+         * @param variable - Variable to differentiate with respect to. When omitted, the
+         * derivative implementation selects the first variable present in the expression.
+         * @param n - Derivative order. The derivative implementation uses first order when omitted.
+         * @returns The symbolic derivative; the receiver is not modified.
+         */
+        diff(variable?: ExpressionInput, n?: Expression | number): Expression;
+        factor(): Expression;
+        integrate(variable?: ExpressionInput): Expression;
+        numeric(precision?: ExpressionInput): Expression;
+        simplify(): Expression;
+        /** Converts this expression to TeX using Nerdamer's converter. */
+        toTeX(options?: TeXOptions): string;
+        /** Converts this expression through Nerdamer's text converter. */
+        toText(): string;
+        /** Legacy alias for TeX conversion. */
+        latex(options?: TeXOptions): string;
+        /** Legacy alias for {@link Expression.isInf}. */
+        isInfinity(): boolean;
+        /** Returns whether this expression's numeric multiplier is fractional. */
+        isFraction(): boolean;
+        /** Returns whether this expression contains an integral. */
+        hasIntegral(): boolean;
+        /** Creates an equation with this expression on the left-hand side. */
+        equals(value: ExpressionInput): Equation;
+        /**
+         * Solves the equation formed by setting this expression equal to zero.
+         *
+         * @param variable - Variable to solve for.
+         * @returns The solver's {@link SolutionSet}, including any exclusions or root metadata it preserves.
+         */
+        solveFor(variable: ExpressionInput): SolutionSet;
+    }
+}
+declare module './core/classes/matrix/Matrix' {
+    interface Matrix extends ChainableApi<Matrix> {
+    }
+}
+declare module './core/classes/vector/Vector' {
+    interface Vector extends ChainableApi<Vector> {
+    }
+}
+declare module './core/classes/collection/Collection' {
+    interface Collection extends ChainableApi<Collection> {
+    }
+}
+declare module './core/classes/dictionary/Dictionary' {
+    interface Dictionary extends ChainableApi<Dictionary> {
+    }
+}
+declare module './core/classes/valuesSet/ValuesSet' {
+    interface ValuesSet extends ScalarApi {
+        diff(variable?: ExpressionInput, n?: Expression | number): this;
+        factor(): this;
+        integrate(variable?: ExpressionInput): this;
+        numeric(precision?: ExpressionInput): this;
+        simplify(): this;
+        subst(value: ExpressionInput, withValue: ExpressionInput): this;
+    }
+}
+declare module './core/classes/equation/Equation' {
+    interface Equation extends ChainableApi<Equation> {
+        /**
+         * Solves this equation for the requested variable.
+         *
+         * @remarks
+         * The solver works from the equation's residual form, `LHS - RHS = 0`, and
+         * returns Nerdamer's {@link SolutionSet}. The equation itself is not modified.
+         *
+         * @param variable - Variable to solve for.
+         * @returns The solver's solution set, including exclusions or root metadata it preserves.
+         */
+        solveFor(variable: ExpressionInput): SolutionSet;
+    }
+}
+/**
+ * Parses Nerdamer notation into a supported parser entity.
+ *
+ * The returned runtime type depends on the notation and can be an
+ * {@link Expression}, equation, or structured parser value. Most type-specific methods
+ * still require the corresponding class guard. Full-package methods declared across all
+ * parser results can be called directly; scalar-only methods such as `buildFunction()`
+ * reject structured results at runtime.
+ *
+ * @remarks
+ * Entries in `values` are substituted while parsing and take precedence over
+ * known parser values, including otherwise restricted names. Parser and
+ * registration settings are shared by this module-level Nerdamer instance.
+ *
+ * @param e - Expression-compatible input to parse.
+ * @param values - Optional name-to-value substitutions for this parse.
+ * @returns The parsed {@link ParserEntity}; inspect its runtime type when the
+ * input can produce more than an Expression.
+ *
+ * @example
+ * ```ts
+ * nerdamer('x+2*x+1').text(); 						// '1+3*x'
+ * nerdamer('2*[a, b, 3]').text(); 					// '[2*a, 2*b, 6]'
+ * nerdamer('x+6*y+a', {x: 1, y: 2, a:'t'}).text(); // '13+t'
+ *
+ * // Evaluation allows even restricted variables to be overridden
+ * nerdamer('e+pi', {π: 1, e: 2}).text(); // '2+pi'
+ * ```
+ */
+declare function nerdamer(e: ExpressionInput, values?: ParserValuesObject): ParserEntity;
+declare namespace nerdamer {
+    var pretty: (e: ParserEntity | string, type?: "TeX" | "text") => string;
+    var convertFromLaTeX: (TeX: string) => ParserEntity;
+    var convertToTeX: (expression: ParserEntity | string, options?: TeXOptions) => string;
+    var convertToLaTeX: (expression: ParserEntity | string, options?: TeXOptions) => string;
+    var setFunction: (name: string, args: string[], body: string) => typeof nerdamer;
+    var setConstant: (name: string, value: number | string) => typeof nerdamer;
+    var getConstant: (name: string) => string;
+    var set: (setting: string | OptionsObject, value?: boolean | string | number | bigint) => typeof nerdamer;
+    var get: (setting: Parameters<typeof Parser.get>[0] | "PRECISION") => number | bigint | boolean | "eng" | "spa" | "fra" | "deu" | "por" | "ita" | "nld";
+    var getOperator: (symbol: string) => import("./api/parser").Operator | undefined;
+    var setOperator: (operator: Parameters<typeof Parser.setOperator>[0], action?: Parameters<typeof Parser.setOperator>[1]) => typeof nerdamer;
+    var aliasOperator: (symbol: string, alias: string) => typeof nerdamer;
+    var setVar: (name: string, value: number | string | "delete") => void;
+    var clearVars: () => typeof nerdamer;
+    var getVars: (option?: "LaTeX" | "text") => Record<string, string>;
+    var functions: () => {
+        user: string[];
+        system: string[];
+    };
+    var symbols: typeof import("./core/classes/expression/shortcuts").symbols;
+    var version: () => string;
+    var errors: typeof import("./core/errors");
+    var buildFunction: typeof build;
+    var classes: {
+        Expression: typeof Expression;
+        Rational: typeof Rational;
+        Polynomial: typeof Polynomial;
+        Matrix: typeof Matrix;
+        Vector: typeof Vector;
+        Collection: typeof Collection;
+        Converter: typeof Converter;
+        Dictionary: typeof Dictionary;
+        ValuesSet: typeof ValuesSet;
+        SolutionSet: typeof SolutionSet;
+        Assumption: typeof Assumption;
+        Equation: typeof Equation;
+        instance: {
+            Parser: {
+                CONSTANTS: ParserConstants;
+                MAX_COMPOUND_OPERATOR_LENGTH: number;
+                operators: Record<string, import("./api/parser").Operator>;
+                VALUE_SETS: string[];
+                WHITE_SPACE: string[];
+                KNOWN_VALUES: Record<string, ParserEntity>;
+                extractIndices(scope: import("./core/common/classes/Scope").Scope, values?: ParserValuesObject, assertive?: boolean): number[] | Expression[];
+                extractStringKeys(scope: import("./core/common/classes/Scope").Scope): string[];
+                aliasOperator(symbol: string, alias: string): /*elided*/ any;
+                create(): /*elided*/ any;
+                evaluate(str: string, values?: ParserValuesObject): ParserEntity;
+                get(setting: keyof typeof import("./core/Settings").Settings): number | bigint | boolean | "eng" | "spa" | "fra" | "deu" | "por" | "ita" | "nld";
+                getI(): string;
+                getOperator(symbol: string): import("./api/parser").Operator | undefined;
+                getPrecision(): number;
+                parse(str: ExpressionInput, values?: ParserValuesObject): ParserEntity;
+                parseRPN(rpn: import("./core/common/classes/Scope").Scope, values?: ParserValuesObject, assertive?: boolean): ParserEntity;
+                parseTeXRPN(rpn: import("./core/common/classes/Scope").Scope): string;
+                scopedBlock(setting: string, value: boolean, callback: () => ParserEntity): ParserEntity;
+                set(setting: string | OptionsObject, value?: boolean | string | number | bigint): /*elided*/ any;
+                setConstants(constants: ParserConstants): void;
+                setI(variable: string): /*elided*/ any;
+                setImaginary(variable: string): /*elided*/ any;
+                setOperator(definition: import("./api/parser").OperatorDefinition, action?: import("./core/classes/parser/types").Operation | import("./core/classes/parser/types").PreFixFunction | import("./core/classes/parser/types").PostFixFunction): /*elided*/ any;
+                setPrecision(precision: number): void;
+                tokenize(inputStr: string, options?: OptionsObject): import("./core/common/classes/Scope").Scope;
+                toRPN(scope: import("./core/common/classes/Scope").Scope): import("./core/common/classes/Scope").Scope;
+            };
+        };
+    };
+    var cos: typeof import("./math/trig").cos;
+    var sin: typeof import("./math/trig").sin;
+    var tan: typeof import("./math/trig").tan;
+    var acos: typeof import("./math/trig").acos;
+    var asin: typeof import("./math/trig").asin;
+    var atan: typeof import("./math/trig").atan;
+    var arccos: typeof import("./math/trig").acos;
+    var arcsin: typeof import("./math/trig").asin;
+    var arctan: typeof import("./math/trig").atan;
+    var atan2: typeof import("./math/trig").atan2;
+    var sec: typeof import("./math/trig").sec;
+    var csc: typeof import("./math/trig").csc;
+    var cot: typeof import("./math/trig").cot;
+    var asec: typeof import("./math/trig").asec;
+    var acsc: typeof import("./math/trig").acsc;
+    var acot: typeof import("./math/trig").acot;
+    var cosh: typeof import("./math/trig").cosh;
+    var sinh: typeof import("./math/trig").sinh;
+    var tanh: typeof import("./math/trig").tanh;
+    var acosh: typeof import("./math/trig").acosh;
+    var asinh: typeof import("./math/trig").asinh;
+    var atanh: typeof import("./math/trig").atanh;
+    var sech: typeof import("./math/trig").sech;
+    var csch: typeof import("./math/trig").csch;
+    var coth: typeof import("./math/trig").coth;
+    var asech: typeof import("./math/trig").asech;
+    var acsch: typeof import("./math/trig").acsch;
+    var acoth: typeof import("./math/trig").acoth;
+    var log: typeof import("./math/math").log;
+    var exp: typeof import("./math/math").exp;
+    var sqrt: typeof import("./math/math").sqrt;
+    var cbrt: typeof import("./math/math").cbrt;
+    var nthroot: typeof import("./math/math").nthroot;
+    var numeric: typeof import("./math/math").numeric;
+    var abs: typeof import("./math/math").abs;
+    var sign: typeof import("./math/math").sign;
+    var min: typeof import("./math/math").min;
+    var max: typeof import("./math/math").max;
+    var round: typeof import("./math/math").round;
+    var floor: typeof import("./math/math").floor;
+    var ceil: typeof ceiling;
+    var trunc: typeof import("./math/trunc").trunc;
+    var hypot: typeof import("./math/geometry").hypot;
+    var fact: typeof import("./math/math").factorial;
+    var factorial: typeof import("./math/math").factorial;
+    var dfact: typeof doubleFactorial;
+    var dfactorial: typeof doubleFactorial;
+    var fib: typeof fibonacci;
+    var mod: typeof import("./math/math").mod;
+    var modInv: typeof import("./math/math").modInv;
+    var isPrime: typeof isprime;
+    var imagpart: typeof imagPart;
+    var realpart: typeof realPart;
+    var polarform: typeof polarForm;
+    var rectform: typeof rectForm;
+    var arg: typeof import("./core/functions/complex").arg;
+    var conjugate: typeof import("./core/functions/complex").conjugate;
+    var csgn: typeof import("./core/functions/complex").csgn;
+    var gamma: typeof import("./math/math").gamma;
+    var erf: typeof import("./math/math").erf;
+    var erfc: typeof import("./math/math").erfc;
+    var heaviside: typeof import("./math/math").heaviside;
+    var delta: typeof dirac;
+    var Ci: typeof import("./math/math").Ci;
+    var Chi: typeof import("./math/math").Chi;
+    var Si: typeof import("./math/math").Si;
+    var Shi: typeof import("./math/math").Shi;
+    var Li: typeof import("./math/math").Li;
+    var Ei: typeof import("./math/math").Ei;
+    var sinc: typeof import("./math/math").sinc;
+    var contains: typeof import("./math/math").contains;
+    var subst: typeof import("./core/functions/subst").subst;
+    var uSub: typeof import("./core/functions/subst").uSub;
+    var uUnSub: typeof import("./core/functions/subst").uUnSub;
+    var expand: typeof import("./core/functions/expand/expand").expand;
+    var factor: typeof import("./algebra/factor/factor").factor;
+    var polyFactors: typeof import("./algebra/factor/factor").polyFactors;
+    var completeSquare: typeof sqcomp;
+    var gcd: typeof import("./algebra/gcd/gcd").gcd;
+    var lcm: typeof import("./algebra/gcd/gcd").lcm;
+    var partfrac: typeof import("./algebra/partfrac").partfrac;
+    var div: typeof polynomialDiv;
+    var divide: typeof polynomialDivide;
+    var simplify: typeof import("./algebra/simplify/simplify").simplify;
+    var groebner: typeof import("./algebra/groebner").groebner;
+    var solve: typeof import("./solve/solve").solve;
+    var solveSystem: typeof import("./solve/solveSystem").solveSystem;
+    var solveeqs: typeof import("./solve/solveSystem").solveSystem;
+    var diff: typeof import("./calculus/derivative/diff").diff;
+    var integrate: typeof import("./calculus/integrate/integrate").integrate;
+    var laplace: typeof import("./calculus/laplace/laplace").laplace;
+    var ilaplace: typeof import("./calculus/laplace/ilaplace").ilaplace;
+    var ilt: typeof import("./calculus/laplace/ilaplace").ilaplace;
+    var sum: typeof import("./math/math").sum;
+    var product: typeof import("./math/math").product;
+    var limit: typeof import("./calculus/limit/limit").limit;
+    var defint: typeof import("./math/math").defint;
+    var S: typeof import("./calculus/fresnel").S;
+    var C: typeof import("./calculus/fresnel").C;
+    var matrix: typeof import("./math/math").matrix;
+    var imatrix: typeof import("./core/classes/matrix/utils").imatrix;
+    var determinant: typeof import("./core/classes/matrix/functions").determinant;
+    var nullspace: typeof import("./core/classes/matrix/functions").nullspace;
+    var dot: typeof import("./core/classes/vector/functions").dot;
+    var cross: typeof import("./core/classes/vector/functions").cross;
+    var deg: typeof import("./core/classes/polynomial/functions").deg;
+    var content: typeof import("./core/classes/polynomial/functions").content;
+    var assume: typeof import("./core/classes/assumption/assume").assume;
+    var updateAPI: () => typeof nerdamer;
+}
+export default nerdamer;