nerdamer 2.0.0-rc.1 → 2.0.0

package/output/index.d.ts

@@ -1,4 +1,3 @@
-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';
@@ -12,10 +11,10 @@ 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 * as errors from './core/errors';
 import { imagPart, polarForm, realPart, rectForm } from './core/functions/complex';
-import { ceiling, dirac, doubleFactorial, fibonacci } from './math/math';
-import { isprime } from './math/utils';
+import { gammaIncomplete, gammaIncompleteLower } from './math/math';
+import { continuedFraction, 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';
@@ -166,8 +165,9 @@ declare namespace 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 get: (setting: Parameters<typeof Parser.get>[0] | "PRECISION") => number | bigint | boolean | errors.Language;
     var getOperator: (symbol: string) => import("./api/parser").Operator | undefined;
+    var isReserved: (name: string) => boolean;
     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;
@@ -177,10 +177,10 @@ declare namespace nerdamer {
         user: string[];
         system: string[];
     };
-    var symbols: typeof import("./core/classes/expression/shortcuts").symbols;
+    var symbols: typeof import("./api/core").symbols;
     var version: () => string;
     var errors: typeof import("./core/errors");
-    var buildFunction: typeof build;
+    var buildFunction: (x: ExpressionInput, argsArray?: string[]) => (...args: number[]) => number;
     var classes: {
         Expression: typeof Expression;
         Rational: typeof Rational;
@@ -202,15 +202,17 @@ declare namespace nerdamer {
                 VALUE_SETS: string[];
                 WHITE_SPACE: string[];
                 KNOWN_VALUES: Record<string, ParserEntity>;
+                extractDictionaryKey(scope: import("./core/common/classes/Scope").Scope, values?: ParserValuesObject, assertive?: boolean): string;
                 extractIndices(scope: import("./core/common/classes/Scope").Scope, values?: ParserValuesObject, assertive?: boolean): number[] | Expression[];
-                extractStringKeys(scope: import("./core/common/classes/Scope").Scope): string[];
+                resolveSymbolicAccess(symbolicTarget: Expression, resolvedTarget: ParserEntity, indices: Expression[]): ParserEntity;
                 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";
+                get(setting: keyof typeof import("./core/Settings").Settings): number | bigint | boolean | errors.Language;
                 getI(): string;
                 getOperator(symbol: string): import("./api/parser").Operator | undefined;
                 getPrecision(): number;
+                isReserved(name: string): boolean;
                 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;
@@ -232,9 +234,9 @@ declare namespace nerdamer {
     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 arccos: (x: ExpressionInput) => Expression;
+    var arcsin: (x: ExpressionInput) => Expression;
+    var arctan: (x: ExpressionInput) => Expression;
     var atan2: typeof import("./math/trig").atan2;
     var sec: typeof import("./math/trig").sec;
     var csc: typeof import("./math/trig").csc;
@@ -255,6 +257,9 @@ declare namespace nerdamer {
     var acsch: typeof import("./math/trig").acsch;
     var acoth: typeof import("./math/trig").acoth;
     var log: typeof import("./math/math").log;
+    var log10: typeof import("./math/math").log10;
+    var radians: typeof import("./math/math").radians;
+    var degrees: typeof import("./math/math").degrees;
     var exp: typeof import("./math/math").exp;
     var sqrt: typeof import("./math/math").sqrt;
     var cbrt: typeof import("./math/math").cbrt;
@@ -266,14 +271,14 @@ declare namespace nerdamer {
     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 ceil: (x: ExpressionInput) => Expression;
     var trunc: typeof import("./math/trunc").trunc;
     var hypot: typeof import("./math/geometry").hypot;
-    var fact: typeof import("./math/math").factorial;
+    var fact: (x: Expression) => Expression;
     var factorial: typeof import("./math/math").factorial;
-    var dfact: typeof doubleFactorial;
-    var dfactorial: typeof doubleFactorial;
-    var fib: typeof fibonacci;
+    var dfact: (x: Expression) => Expression;
+    var dfactorial: (x: Expression) => Expression;
+    var fib: (x: ExpressionInput) => Expression;
     var mod: typeof import("./math/math").mod;
     var modInv: typeof import("./math/math").modInv;
     var isPrime: typeof isprime;
@@ -285,10 +290,15 @@ declare namespace nerdamer {
     var conjugate: typeof import("./core/functions/complex").conjugate;
     var csgn: typeof import("./core/functions/complex").csgn;
     var gamma: typeof import("./math/math").gamma;
+    var gamma_incomplete: typeof gammaIncomplete;
+    var gamma_incomplete_lower: typeof gammaIncompleteLower;
     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 step: typeof import("./math/math").step;
+    var rect: typeof import("./math/math").rect;
+    var tri: typeof import("./math/math").tri;
+    var delta: (x: Expression) => Expression;
     var Ci: typeof import("./math/math").Ci;
     var Chi: typeof import("./math/math").Chi;
     var Si: typeof import("./math/math").Si;
@@ -296,44 +306,54 @@ declare namespace nerdamer {
     var Li: typeof import("./math/math").Li;
     var Ei: typeof import("./math/math").Ei;
     var sinc: typeof import("./math/math").sinc;
+    var parens: typeof import("./math/math").parens;
+    var continued_fraction: typeof continuedFraction;
+    var scientific: typeof import("./math/math").scientific;
     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 uSub: typeof import("./api/algebra").uSub;
+    var uUnSub: typeof import("./api/algebra").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 factor: typeof import("./api/algebra").factor;
+    var pfactor: typeof import("./api/algebra").pfactor;
+    var pfactord: typeof import("./api/algebra").pfactord;
+    var polyFactors: typeof import("./api/algebra").polyFactors;
+    var completeSquare: (expr: ExpressionInput, variable?: string) => import("./algebra/utils").CompleteSquareResult;
+    var gcd: typeof import("./api/algebra").gcd;
+    var lcm: typeof import("./api/algebra").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 simplify: typeof import("./api/algebra").simplify;
     var groebner: typeof import("./algebra/groebner").groebner;
     var solve: typeof import("./solve/solve").solve;
+    var roots: typeof import("./solve/solve").roots;
     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 ilt: (expr: ExpressionInput, s: ExpressionInput, t: ExpressionInput) => Expression;
     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 defint: typeof import("./math/defint/defint").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 invert: typeof import("./core/classes/matrix/functions").invert;
     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 line: typeof import("./math/geometry").line;
+    var deg: typeof import("./api/algebra").deg;
+    var content: typeof import("./api/algebra").content;
+    var coeffs: typeof import("./api/algebra").coeffs;
     var assume: typeof import("./core/classes/assumption/assume").assume;
+    var getAssumptions: typeof import("./core/classes/assumption/assume").getAssumptions;
     var updateAPI: () => typeof nerdamer;
 }
 export default nerdamer;

package/output/index.js

@@ -42,7 +42,8 @@ const gcd_1 = require("./algebra/gcd/gcd");
 const groebner_1 = require("./algebra/groebner");
 const partfrac_1 = require("./algebra/partfrac");
 const simplify_1 = require("./algebra/simplify/simplify");
-const utils_1 = require("./algebra/utils");
+const algebra_1 = require("./api/algebra");
+const core_1 = require("./api/core");
 const diff_1 = require("./calculus/derivative/diff");
 const fresnel_1 = require("./calculus/fresnel");
 const integrate_1 = require("./calculus/integrate/integrate");
@@ -58,7 +59,7 @@ const Expression_1 = require("./core/classes/expression/Expression");
 const shortcuts_1 = require("./core/classes/expression/shortcuts");
 const functions_1 = require("./core/classes/matrix/functions");
 const Matrix_1 = require("./core/classes/matrix/Matrix");
-const utils_2 = require("./core/classes/matrix/utils");
+const utils_1 = require("./core/classes/matrix/utils");
 const constants_1 = require("./core/classes/parser/constants");
 const Parser_1 = require("./core/classes/parser/Parser");
 const scope_1 = require("./core/classes/parser/scripting/scope");
@@ -71,19 +72,21 @@ const Vector_1 = require("./core/classes/vector/Vector");
 const Converter_1 = require("./core/converters/Converter");
 const dispatch_1 = require("./core/dispatch");
 const errors = __importStar(require("./core/errors"));
-const build_1 = require("./core/functions/build");
+const fullFunctions_1 = require("./core/fullFunctions");
 const complex_1 = require("./core/functions/complex");
 const expand_1 = require("./core/functions/expand/expand");
 const setFunction_1 = require("./core/functions/setFunction");
 const subst_1 = require("./core/functions/subst");
+const defint_1 = require("./math/defint/defint");
 const geometry_1 = require("./math/geometry");
 const math_1 = require("./math/math");
 const trig_1 = require("./math/trig");
 const trunc_1 = require("./math/trunc");
-const utils_3 = require("./math/utils");
+const utils_2 = require("./math/utils");
 const SolutionSet_1 = require("./solve/classes/SolutionSet");
 const solve_1 = require("./solve/solve");
 const solveSystem_1 = require("./solve/solveSystem");
+(0, fullFunctions_1.registerNerdamerFunctions)();
 /**
  * Adds selected root functions as instance methods without changing the source classes.
  * Existing class methods win, so a class can keep a more specific implementation.
@@ -412,6 +415,10 @@ nerdamer.get = function (setting) {
 nerdamer.getOperator = function (symbol) {
     return Parser_1.Parser.getOperator(symbol);
 };
+/** Returns whether Nerdamer currently reserves a variable or symbol name. */
+nerdamer.isReserved = function (name) {
+    return Parser_1.Parser.isReserved(name);
+};
 /** Registers or updates a parser operator and returns the root API for chaining. */
 nerdamer.setOperator = function (operator, action) {
     Parser_1.Parser.setOperator(operator, action);
@@ -529,7 +536,7 @@ nerdamer.errors = errors;
  * nerdamer('cos(x)').buildFunction(['x'])(0);			// 1
  * ```
  */
-nerdamer.buildFunction = build_1.build;
+nerdamer.buildFunction = core_1.buildFunction;
 /**
  * Compatibility registry of selected Nerdamer constructors and the shared Parser instance.
  *
@@ -565,9 +572,36 @@ nerdamer.tan = trig_1.tan;
 nerdamer.acos = trig_1.acos;
 nerdamer.asin = trig_1.asin;
 nerdamer.atan = trig_1.atan;
-nerdamer.arccos = trig_1.acos;
-nerdamer.arcsin = trig_1.asin;
-nerdamer.arctan = trig_1.atan;
+const arccos = trig_1.acos;
+/**
+ * Alias for `nerdamer.acos`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.arccos('1/2').text(); // "1/3*pi"
+ * ```
+ */
+nerdamer.arccos = arccos;
+const arcsin = trig_1.asin;
+/**
+ * Alias for `nerdamer.asin`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.arcsin('1/2').text(); // "1/6*pi"
+ * ```
+ */
+nerdamer.arcsin = arcsin;
+const arctan = trig_1.atan;
+/**
+ * Alias for `nerdamer.atan`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.arctan(1).text(); // "1/4*pi"
+ * ```
+ */
+nerdamer.arctan = arctan;
 nerdamer.atan2 = trig_1.atan2;
 nerdamer.sec = trig_1.sec;
 nerdamer.csc = trig_1.csc;
@@ -590,6 +624,9 @@ nerdamer.acsch = trig_1.acsch;
 nerdamer.acoth = trig_1.acoth;
 // Elementary and numeric functions
 nerdamer.log = math_1.log;
+nerdamer.log10 = math_1.log10;
+nerdamer.radians = math_1.radians;
+nerdamer.degrees = math_1.degrees;
 nerdamer.exp = math_1.exp;
 nerdamer.sqrt = math_1.sqrt;
 nerdamer.cbrt = math_1.cbrt;
@@ -601,18 +638,63 @@ nerdamer.min = math_1.min;
 nerdamer.max = math_1.max;
 nerdamer.round = math_1.round;
 nerdamer.floor = math_1.floor;
-nerdamer.ceil = math_1.ceiling;
+const ceil = math_1.ceiling;
+/**
+ * Rounds a value up to the nearest integer.
+ *
+ * @example
+ * ```ts
+ * nerdamer.ceil('3.2').text(); // "4"
+ * ```
+ */
+nerdamer.ceil = ceil;
 nerdamer.trunc = trunc_1.trunc;
 nerdamer.hypot = geometry_1.hypot;
 // Discrete and number-theoretic functions
-nerdamer.fact = math_1.factorial;
+const fact = math_1.factorial;
+/**
+ * Alias for `nerdamer.factorial`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.fact(5).text(); // "120"
+ * ```
+ */
+nerdamer.fact = fact;
 nerdamer.factorial = math_1.factorial;
-nerdamer.dfact = math_1.doubleFactorial;
-nerdamer.dfactorial = math_1.doubleFactorial;
-nerdamer.fib = math_1.fibonacci;
+const dfact = math_1.doubleFactorial;
+/**
+ * Computes the double factorial of an expression.
+ *
+ * @example
+ * ```ts
+ * nerdamer.dfact(6).text(); // "48"
+ * ```
+ */
+nerdamer.dfact = dfact;
+const dfactorial = math_1.doubleFactorial;
+/**
+ * Computes the double factorial of an expression.
+ *
+ * @example
+ * ```ts
+ * nerdamer.dfactorial(7).text(); // "105"
+ * ```
+ */
+nerdamer.dfactorial = dfactorial;
+const fib = math_1.fibonacci;
+/**
+ * Computes the Fibonacci number for an integer index.
+ *
+ * @example
+ * ```ts
+ * nerdamer.fib(10).text(); // "55"
+ * ```
+ */
+nerdamer.fib = fib;
 nerdamer.mod = math_1.mod;
 nerdamer.modInv = math_1.modInv;
-nerdamer.isPrime = utils_3.isprime;
+nerdamer.isPrime = utils_2.isprime;
 // Complex functions
 nerdamer.imagpart = complex_1.imagPart;
 nerdamer.realpart = complex_1.realPart;
@@ -623,10 +705,24 @@ nerdamer.conjugate = complex_1.conjugate;
 nerdamer.csgn = complex_1.csgn;
 // Special functions
 nerdamer.gamma = math_1.gamma;
+nerdamer.gamma_incomplete = math_1.gammaIncomplete;
+nerdamer.gamma_incomplete_lower = math_1.gammaIncompleteLower;
 nerdamer.erf = math_1.erf;
 nerdamer.erfc = math_1.erfc;
 nerdamer.heaviside = math_1.heaviside;
-nerdamer.delta = math_1.dirac;
+nerdamer.step = math_1.step;
+nerdamer.rect = math_1.rect;
+nerdamer.tri = math_1.tri;
+const delta = math_1.dirac;
+/**
+ * Evaluates the Dirac delta function when the input is known to be nonzero.
+ *
+ * @example
+ * ```ts
+ * nerdamer.delta(5).text(); // "0"
+ * ```
+ */
+nerdamer.delta = delta;
 nerdamer.Ci = math_1.Ci;
 nerdamer.Chi = math_1.Chi;
 nerdamer.Si = math_1.Si;
@@ -635,6 +731,9 @@ nerdamer.Li = math_1.Li;
 nerdamer.Ei = math_1.Ei;
 nerdamer.sinc = math_1.sinc;
 // Symbolic utilities
+nerdamer.parens = math_1.parens;
+nerdamer.continued_fraction = utils_2.continuedFraction;
+nerdamer.scientific = math_1.scientific;
 nerdamer.contains = math_1.contains;
 nerdamer.subst = subst_1.subst;
 nerdamer.uSub = subst_1.uSub;
@@ -642,8 +741,18 @@ nerdamer.uUnSub = subst_1.uUnSub;
 // Algebra
 nerdamer.expand = expand_1.expand;
 nerdamer.factor = factor_1.factor;
+nerdamer.pfactor = factor_1.pfactor;
+nerdamer.pfactord = factor_1.pfactord;
 nerdamer.polyFactors = factor_1.polyFactors;
-nerdamer.completeSquare = utils_1.sqcomp;
+/**
+ * Completes the square for a quadratic expression.
+ *
+ * @example
+ * ```ts
+ * nerdamer.completeSquare('x^2+6*x+1').expression.text({ sort: true }); // "(3+x)^2-8"
+ * ```
+ */
+nerdamer.completeSquare = algebra_1.completeSquare;
 nerdamer.gcd = gcd_1.gcd;
 nerdamer.lcm = gcd_1.lcm;
 nerdamer.partfrac = partfrac_1.partfrac;
@@ -653,6 +762,7 @@ nerdamer.simplify = simplify_1.simplify;
 nerdamer.groebner = groebner_1.groebner;
 // Solvers
 nerdamer.solve = solve_1.solve;
+nerdamer.roots = solve_1.roots;
 nerdamer.solveSystem = solveSystem_1.solveSystem;
 nerdamer.solveeqs = solveSystem_1.solveSystem;
 // Calculus
@@ -660,24 +770,36 @@ nerdamer.diff = diff_1.diff;
 nerdamer.integrate = integrate_1.integrate;
 nerdamer.laplace = laplace_1.laplace;
 nerdamer.ilaplace = ilaplace_1.ilaplace;
-nerdamer.ilt = ilaplace_1.ilaplace;
+const ilt = ilaplace_1.ilaplace;
+/**
+ * Alias for `nerdamer.ilaplace`.
+ *
+ * @example
+ * ```ts
+ * nerdamer.ilt('1/(s^2+1)', 's', 't').text();
+ * ```
+ */
+nerdamer.ilt = ilt;
 nerdamer.sum = math_1.sum;
 nerdamer.product = math_1.product;
 nerdamer.limit = limit_1.limit;
-nerdamer.defint = math_1.defint;
+nerdamer.defint = defint_1.defint;
 nerdamer.S = fresnel_1.S;
 nerdamer.C = fresnel_1.C;
 // Matrix operations
 nerdamer.matrix = math_1.matrix;
-nerdamer.imatrix = utils_2.imatrix;
+nerdamer.imatrix = utils_1.imatrix;
 nerdamer.determinant = functions_1.determinant;
+nerdamer.invert = functions_1.invert;
 nerdamer.nullspace = functions_1.nullspace;
 // Vector operations
 nerdamer.dot = functions_3.dot;
 nerdamer.cross = functions_3.cross;
+nerdamer.line = geometry_1.line;
 // Polynomial operations
 nerdamer.deg = functions_2.deg;
 nerdamer.content = functions_2.content;
+nerdamer.coeffs = functions_2.coeffs;
 // Assumptions
 /**
  * Registers a process-wide numeric interval assumption.
@@ -689,6 +811,12 @@ nerdamer.content = functions_2.content;
  * directly can use the documented assumption-domain functions.
  */
 nerdamer.assume = assume_1.assume;
+/**
+ * Returns a snapshot of all process-wide assumptions currently registered by symbol.
+ *
+ * Changing the returned Map does not change Nerdamer's active assumptions.
+ */
+nerdamer.getAssumptions = assume_1.getAssumptions;
 // -----------------------------------------------------------------------------
 // Complete the full-package instance API
 // -----------------------------------------------------------------------------

package/output/math/defint/defint.d.ts

@@ -0,0 +1,18 @@
+import { Expression } from '../../core/classes/expression/Expression';
+import type { ExpressionInput } from '../../core/types';
+/**
+ * Calculates the definite integral using Adaptive Simpson. Note that this function uses
+ * native JS number due to severe computational overhead when implemented with Decimal.js.
+ *
+ * @param f The function being integrated
+ * @param dx The variable of integration
+ * @param from The lower limit of the integral
+ * @param to The upper limit of the integral
+ * @returns The numeric value if possible else a symbolic function
+ *
+ * @example
+ * ```ts
+ * defint('cos(x)-x^2+6', 'x', 1, 6); // -42.787553149673464
+ * ```
+ */
+export declare function defint(f: ExpressionInput, dx: ExpressionInput, from: ExpressionInput, to: ExpressionInput): Expression;

package/output/math/defint/defint.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defint = defint;
+const Expression_1 = require("../../core/classes/expression/Expression");
+const utils_1 = require("../../core/classes/expression/utils");
+const constants_1 = require("../../core/classes/parser/constants");
+const defintNative_1 = require("./defintNative");
+const NATIVE_DEFINITE_INTEGRATION_PRECISION = 17;
+/**
+ * Calculates the definite integral using Adaptive Simpson. Note that this function uses
+ * native JS number due to severe computational overhead when implemented with Decimal.js.
+ *
+ * @param f The function being integrated
+ * @param dx The variable of integration
+ * @param from The lower limit of the integral
+ * @param to The upper limit of the integral
+ * @returns The numeric value if possible else a symbolic function
+ *
+ * @example
+ * ```ts
+ * defint('cos(x)-x^2+6', 'x', 1, 6); // -42.787553149673464
+ * ```
+ */
+function defint(f, dx, from, to) {
+    let retval;
+    f = Expression_1.Expression.create(f);
+    dx = Expression_1.Expression.create(dx);
+    from = Expression_1.Expression.create(from);
+    to = Expression_1.Expression.create(to);
+    const inputVars = f.variables();
+    // Get the variable
+    const v = (0, utils_1.assertPlainVariableAndGetString)(dx);
+    // Pull factors that are constant with respect to the integration variable across the bounds.
+    if (!inputVars.includes(v)) {
+        retval = f.times(to.minus(from));
+    }
+    else {
+        let numericFrom = from;
+        let numericTo = to;
+        if (!numericFrom.isNUM() && numericFrom.isConstant()) {
+            numericFrom = numericFrom.evaluate();
+        }
+        if (!numericTo.isNUM() && numericTo.isConstant()) {
+            numericTo = numericTo.evaluate();
+        }
+        if (inputVars.length === 1 &&
+            inputVars[0] === v &&
+            numericFrom.isNUM() &&
+            numericTo.isNUM()) {
+            const a = Number(numericFrom.getMultiplier().toDecimal());
+            const b = Number(numericTo.getMultiplier().toDecimal());
+            retval = Expression_1.Expression.create((0, defintNative_1.definiteIntegrateNative)(f.buildFunction(), a, b));
+            retval.precision = NATIVE_DEFINITE_INTEGRATION_PRECISION; // Mark it as limited precision
+        }
+        else {
+            retval = Expression_1.Expression.toFunction(constants_1.DEFINT, [f, dx, from, to]);
+        }
+    }
+    return retval;
+}

package/output/math/defint/defintDecimal.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.definiteIntegrate = definiteIntegrate;
 const decimal_js_1 = __importDefault(require("decimal.js"));
+const errors_1 = require("../../core/errors");
 const TWO = new decimal_js_1.default(2);
 const FOUR = new decimal_js_1.default(4);
 const SIX = new decimal_js_1.default(6);
@@ -58,12 +59,12 @@ function withFiniteBounds(f, aIn, bIn, opts) {
     let evals = 0;
     const evalF = (x) => {
         if (evals++ > opts.maxEvals) {
-            throw new Error(`defint: maxEvals exceeded (${opts.maxEvals}).`);
+            throw new Error((0, errors_1.message)('defintMaxEvals', { max: String(opts.maxEvals) }));
         }
         const y = f(x);
         if (opts.singular === 'strict') {
             if (!isFiniteDecimal(y)) {
-                throw new Error(`defint: non-finite f(x) at x=${x.toString()}`);
+                throw new Error((0, errors_1.message)('defintNonFiniteValue', { x: x.toString() }));
             }
         }
         return y;
@@ -127,7 +128,7 @@ function withFiniteBounds(f, aIn, bIn, opts) {
                 !isFiniteDecimal(fr.fm) ||
                 !isFiniteDecimal(fr.fb)) {
                 if (fr.depth >= opts.maxDepth || fr.singularTries >= MAX_SINGULAR_REFINEMENT_ATTEMPTS) {
-                    throw new Error(`defint: singular/non-finite encountered near [${a0.toString()}, ${b0.toString()}]`);
+                    throw new Error((0, errors_1.message)('defintSingularity', { a: a0.toString(), b: b0.toString() }));
                 }
                 // Push children without using Simpson error test; just refine around the issue.
                 const nextDepth = fr.depth + 1;
@@ -251,7 +252,7 @@ function definiteIntegrate(f, a, b, options = {}) {
     const isInfA = !A.isFinite() && !A.isNaN();
     const isInfB = !B.isFinite() && !B.isNaN();
     if ((isInfA || isInfB) && !allowInfinite) {
-        throw new Error(`defint: infinite bounds require allowInfinite:true`);
+        throw new Error((0, errors_1.message)('defintInfiniteBoundsDecimal'));
     }
     const coreOpts = { tolAbs, tolRel, maxDepth, maxEvals, singular };
     // Handle infinite bounds with standard substitutions:
@@ -299,7 +300,7 @@ function definiteIntegrate(f, a, b, options = {}) {
             const eps = new decimal_js_1.default(10).pow(-(decimal_js_1.default.precision ?? DEFAULT_DECIMAL_PRECISION) + INFINITE_BOUND_PRECISION_SLACK);
             return withFiniteBounds(g, eps, ONE.sub(eps), coreOpts);
         }
-        throw new Error(`defint: unsupported infinite bound configuration`);
+        throw new Error((0, errors_1.message)('defintUnsupportedInfiniteBounds'));
     }
     // Finite-bounds path, with optional segmentation by breakpoints
     if (bps.length === 0) {