@lakutata/math 0.0.0-stage → 3.1.5

package/dist/cjs/lib/MathScope.d.ts

@@ -0,0 +1,268 @@
+import { type AsyncOptions, Context } from './Context.js';
+import { Decimal, type DecimalOptions, type DecimalValue } from './Decimal.js';
+import { Matrix, type MatrixValue } from './Matrix.js';
+import { Equation, Expression, Inequality, type Value } from './Expression.js';
+import { ExpressionMatrix, type ExpressionMatrixValue } from './ExpressionMatrix.js';
+import { LinearAlgebra } from './LinearAlgebra.js';
+import { type IntervalOptions, type MathSet } from './MathSet.js';
+import { NumberTheory } from './NumberTheory.js';
+import { Numeric } from './Numeric.js';
+import { Polynomials } from './Polynomials.js';
+import { Statistics } from './Statistics.js';
+import { type CustomUnits, type Unit, type UnitValue } from './Unit.js';
+import type { PhysicalConstant } from './UnitTable.js';
+/**
+ * One solution of a system of equations: the values of the variables it determines, by their names. When the system
+ * does not determine every variable, the values are given in terms of the other ones (`{x: '-y + 3'}`).
+ */
+export type SystemSolution = Record<string, Expression>;
+/**
+ * An equation of a system: an equation, a formula (`'x + y = 3'`), or an expression equal to zero
+ */
+export type SystemEquation = Equation | Expression | string;
+/**
+ * The definitions of formulas: a body by signature (`{'f(x)': 'x^2 + 1', 'g': 9.80665}`)
+ */
+export type MathDefinitions = Record<string, string | number>;
+/**
+ * The common subexpressions of expressions: the replacements, in order, and the expressions written with them
+ */
+export interface CommonSubexpressions {
+    /**
+     * The subexpressions met more than once, each with its name; a value may use the names before it.
+     */
+    replacements: {
+        name: string;
+        value: Expression;
+    }[];
+    /**
+     * The expressions, written with the names of the replacements.
+     */
+    expressions: Expression[];
+}
+/**
+ * The options of `cse()`
+ */
+export interface CseOptions {
+    /**
+     * The prefix of the names of the replacements: `x` by default (`x0`, `x1`…). Names already used by variables of
+     * the expressions are skipped.
+     */
+    prefix?: string;
+}
+/**
+ * The options of `createMath()`: all of them have a default value
+ */
+export interface MathOptions {
+    /**
+     * The functions and the constants its formulas use: a body by signature (`{'f(x)': 'x^2 + 1', 'g': 9.80665}`).
+     * They do not change once it is created; `with()` adds others for a while. None by default.
+     */
+    definitions?: MathDefinitions;
+    /**
+     * The significant digits of `toDecimal()` and of `decimal()` when none are given: an integer from 1 to 100000.
+     * @default 32
+     */
+    precision?: number;
+    /**
+     * The time limit of the asynchronous operations when none is given, in milliseconds: 0 for none.
+     * @default 0
+     */
+    timeout?: number;
+    /**
+     * How many of its asynchronous operations run at the same time in the threads of the addon (the others wait their
+     * turn): all of its threads by default (the processor's cores minus one, or the environment variable
+     * `LAKUTATA_MATH_THREADS`).
+     */
+    concurrency?: number;
+    /**
+     * Units added to those of the table, by their names: a definition (`{furlong: '220 yd'}`), or a definition with
+     * prefixes, other names, an offset (`{knot: {definition: '1852 m/h', aliases: ['knots']}}`). A name that is already
+     * a unit, alone or with a prefix (`kt` is `k t`), throws `MathDefinitionException`. The scopes of `with()` have
+     * them too. None by default.
+     */
+    units?: CustomUnits;
+}
+/**
+ * A scope of definitions and settings: its formulas are parsed with its definitions (`parse()`, `expression()`,
+ * `equation()`), and its decimals, matrices, systems of equations, number theory, linear algebra, statistics and
+ * numeric solutions use its settings. `createMath()` makes one; `with()` gives another one over it, for definitions
+ * used for a while (they do not change it). The functions exported by the package (`expression()`, `linalg`…) belong to
+ * `math`, the scope made with the default options.
+ * @example
+ * ```typescript
+ * import {createMath, type MathScope} from '@lakutata/math'
+ *
+ * const math: MathScope = createMath({definitions: {'tax(x)': 'x * 0.13'}, precision: 50})
+ * console.log(math.expression('tax(200)').toNumber())                     //26
+ * const scope: MathScope = math.with({'area(r)': 'pi*r^2'})
+ * console.log(scope.expression('area(2)').toString())                     //4pi
+ * console.log(scope.expression('area(r)').diff('r').toString())           //2pi*r
+ * ```
+ */
+export declare class MathScope {
+    #private;
+    protected readonly context: Context;
+    /**
+     * A scope over a context. Made by `createMath()` and by `with()`.
+     * @param context The context: its definitions, its settings.
+     */
+    constructor(context: Context);
+    /**
+     * The number theory of the integers (bigints): primes, factorization, modular arithmetic, integer sequences,
+     * combinatorial numbers, counting and continued fractions. Its asynchronous operations share the threads, the time
+     * limit and the concurrency of the scope.
+     */
+    get ntheory(): NumberTheory;
+    /**
+     * The polynomials: their greatest common divisor, least common multiple, resultant and discriminant, exactly. Its
+     * asynchronous operations share the threads, the time limit and the concurrency of the scope.
+     */
+    get poly(): Polynomials;
+    /**
+     * The numeric linear algebra (on Eigen): matrices of zeros, identities, rotations; products, norms; the solutions
+     * of linear systems, least squares, inverses, determinants, ranks, decompositions, functions of matrices, sparse
+     * matrices.
+     */
+    get linalg(): LinearAlgebra;
+    /**
+     * The statistics of values (arrays of numbers, or `Float64Array`s): sums, means, medians, modes, variances,
+     * quantiles, covariances, correlations; the probability distributions (`normal()` … `hypergeometric()`) and a
+     * generator of random numbers (`random()`).
+     */
+    get stats(): Statistics;
+    /**
+     * The numeric solutions of equations, the integrals and the differential equations: the roots of polynomials, a
+     * root of a function, a solution of a system of nonlinear equations, the integral of a function, the solution of
+     * ordinary differential equations.
+     */
+    get numeric(): Numeric;
+    /**
+     * Parse a formula: an expression (`x^2 - 5x + 6`), an equation (`x^2 = 4`), an inequality (`x^2 < 4`), or a matrix
+     * (`[1, x; x^2, 2]`, `[1, 2; 3, 4] * [x; y]`, `inv(…)`); `det(…)` and `trace(…)` of a matrix are expressions.
+     * @param text The formula.
+     */
+    parse(text: string): Expression | Equation | Inequality | ExpressionMatrix;
+    /**
+     * A matrix of expressions: of its rows (expressions, numbers or formulas: `[[1, 'x'], ['x^2', 2]]`), of a formula
+     * of a matrix (`'[1, x; x^2, 2]'`), or of a matrix of numbers (each the decimal it prints as).
+     * @param value The rows, the formula, or the matrix.
+     */
+    expressionMatrix(value: ExpressionMatrixValue): ExpressionMatrix;
+    /**
+     * An interval of real numbers: empty when the start is after the end, a value when they are equal and included.
+     * @param start The start (`-inf` for none): an exact real number, an expression or a formula.
+     * @param end The end (`inf` for none).
+     * @param options Whether the ends are excluded (both included by default).
+     */
+    interval(start: Value, end: Value, options?: IntervalOptions): MathSet;
+    /**
+     * A finite set of values: each one once, the real ones sorted, then the others as they are given.
+     * @param values The values: expressions, numbers or formulas.
+     */
+    finiteSet(values: readonly Value[]): MathSet;
+    /**
+     * The Jacobian matrix of expressions by variables: a row for each expression, its derivatives by the variables.
+     * @param expressions The expressions (or formulas).
+     * @param variables The variables.
+     */
+    jacobian(expressions: Value[], variables: string[]): ExpressionMatrix;
+    /**
+     * An expression: a formula parsed (an equation is an error), or the exact value of a number (`0.1` is `1/10`).
+     * @param value The formula, or the number.
+     */
+    expression(value: Value): Expression;
+    /**
+     * A decimal of a precision: a value rounded to that many significant digits (halves to even). A number is read by
+     * its shortest representation (`0.1` is 0.1), a string as a decimal number (`'19.99'`); an expression is computed,
+     * as `toDecimal()` does.
+     * @param value A decimal number (a number, a bigint, a string, a decimal) or an expression without variables.
+     * @param options The precision: the one of the scope by default.
+     */
+    decimal(value: DecimalValue | Expression, options?: DecimalOptions): Decimal;
+    /**
+     * A value with units: of a formula of units (`'5 cm + 2 inch'`, `'9.8 m/s^2'`), or of a number and its units
+     * (`unit(5, 'cm')`); a number alone has no units. The names of a formula of units are units (of the table, with
+     * their prefixes, or of the options), `pi`, `e` and `i`.
+     * @param value The formula of units, or the number (a number, an expression, a formula of `expression()`).
+     * @param units The units of the number: a formula of units without a number (`'m/s^2'`).
+     */
+    unit(value: UnitValue, units?: string): Unit;
+    /**
+     * A physical constant with its units (`constant('speedOfLight')` is `299792458 m / s`): the values of CODATA 2022,
+     * those that the SI defines exactly are their exact formulas (`reducedPlanckConstant` is `6.62607015e-34/(2pi) J
+     * s`).
+     * @param name The name of the constant.
+     */
+    constant(name: PhysicalConstant): Unit;
+    /**
+     * A matrix of numbers: of its rows (`[[1, 2], [3, 4]]`), or a copy of a matrix.
+     * @param value The rows, or a matrix.
+     */
+    matrix(value: MatrixValue): Matrix;
+    /**
+     * An equation: a formula with `=` parsed.
+     * @param text The formula.
+     */
+    equation(text: string): Equation;
+    /**
+     * A scope over this one, its definitions added: they are used by the formulas parsed by it, and replace the ones
+     * of the same name.
+     * @param definitions A body by signature: `{'h(x)': 'f(x) + 1'}`.
+     */
+    with(definitions: MathDefinitions): MathScope;
+    /**
+     * The solutions of a system of linear equations: none (an empty array), or one, with the values of the variables
+     * it determines.
+     * @param equations The equations: formulas, equations, or expressions equal to zero.
+     * @param variables The variables to solve for.
+     */
+    solve(equations: SystemEquation[], variables: string[]): SystemSolution[];
+    /**
+     * `solve()` in the threads of the addon.
+     * @param equations The equations: formulas, equations, or expressions equal to zero.
+     * @param variables The variables to solve for.
+     * @param options Its cancellation, its time limit.
+     */
+    solveAsync(equations: SystemEquation[], variables: string[], options?: AsyncOptions): Promise<SystemSolution[]>;
+    /**
+     * The common subexpressions of expressions (common subexpression elimination): the parts met more than once,
+     * named, and the expressions rewritten with them. Printed with `toJavaScript()` or `toC()`, the result is code that
+     * computes each part only once.
+     * @param expressions The expressions: expressions, numbers or formulas.
+     * @param options The prefix of the names.
+     * @example
+     * ```typescript
+     * import {math} from '@lakutata/math'
+     *
+     * function shared(): string {
+     *     const {replacements, expressions} = math.cse(['sin(x + y)^2 + x + y', 'cos(x + y)'])
+     *     //x0 = x + y; the expressions: x0 + sin(x0)^2, cos(x0)
+     *     const lines: string[] = replacements.map(({name, value}) => `const ${name} = ${value.toJavaScript()}`)
+     *     return [...lines, `return [${expressions.map((expression) => expression.toJavaScript()).join(', ')}]`].join('\n')
+     * }
+     * ```
+     */
+    cse(expressions: Value[], options?: CseOptions): CommonSubexpressions;
+    /**
+     * `cse()` in the threads of the addon.
+     * @param expressions The expressions: expressions, numbers or formulas.
+     * @param options The prefix of the names, the cancellation, the time limit.
+     */
+    cseAsync(expressions: Value[], options?: CseOptions & AsyncOptions): Promise<CommonSubexpressions>;
+}
+/**
+ * A scope of definitions and settings (`MathScope`) with these options: the package exports the one made with the
+ * default options, `math`, and its functions (`expression()`, `linalg`…). Its options are checked
+ * (`MathArgumentException`).
+ * @param options Its definitions, the precision of its decimals, the time limit and the concurrency of its
+ * asynchronous operations: all of them have a default value.
+ * @example
+ * ```typescript
+ * import {createMath, type MathScope} from '@lakutata/math'
+ *
+ * const finance: MathScope = createMath({definitions: {'vat(x)': 'x * 0.2'}, precision: 40, timeout: 5000})
+ * console.log(finance.expression('vat(150)').toNumber())                  //30
+ * ```
+ */
+export declare function createMath(options?: MathOptions): MathScope;

package/dist/cjs/lib/MathScope.js

@@ -0,0 +1,316 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MathScope = void 0;
+exports.createMath = createMath;
+const MathArgumentException_js_1 = require("../exceptions/MathArgumentException.js");
+const MathSyntaxException_js_1 = require("../exceptions/MathSyntaxException.js");
+const Context_js_1 = require("./Context.js");
+const Decimal_js_1 = require("./Decimal.js");
+const Matrix_js_1 = require("./Matrix.js");
+const Expression_js_1 = require("./Expression.js");
+const ExpressionMatrix_js_1 = require("./ExpressionMatrix.js");
+const LinearAlgebra_js_1 = require("./LinearAlgebra.js");
+const MathSet_js_1 = require("./MathSet.js");
+const Native_js_1 = require("./Native.js");
+const NumberTheory_js_1 = require("./NumberTheory.js");
+const Numeric_js_1 = require("./Numeric.js");
+const Polynomials_js_1 = require("./Polynomials.js");
+const Statistics_js_1 = require("./Statistics.js");
+const Unit_js_1 = require("./Unit.js");
+/**
+ * A scope of definitions and settings: its formulas are parsed with its definitions (`parse()`, `expression()`,
+ * `equation()`), and its decimals, matrices, systems of equations, number theory, linear algebra, statistics and
+ * numeric solutions use its settings. `createMath()` makes one; `with()` gives another one over it, for definitions
+ * used for a while (they do not change it). The functions exported by the package (`expression()`, `linalg`…) belong to
+ * `math`, the scope made with the default options.
+ * @example
+ * ```typescript
+ * import {createMath, type MathScope} from '@lakutata/math'
+ *
+ * const math: MathScope = createMath({definitions: {'tax(x)': 'x * 0.13'}, precision: 50})
+ * console.log(math.expression('tax(200)').toNumber())                     //26
+ * const scope: MathScope = math.with({'area(r)': 'pi*r^2'})
+ * console.log(scope.expression('area(2)').toString())                     //4pi
+ * console.log(scope.expression('area(r)').diff('r').toString())           //2pi*r
+ * ```
+ */
+class MathScope {
+    #ntheory;
+    #poly;
+    #linalg;
+    #stats;
+    #numeric;
+    /**
+     * A scope over a context. Made by `createMath()` and by `with()`.
+     * @param context The context: its definitions, its settings.
+     */
+    constructor(context) {
+        this.context = context;
+    }
+    /**
+     * The number theory of the integers (bigints): primes, factorization, modular arithmetic, integer sequences,
+     * combinatorial numbers, counting and continued fractions. Its asynchronous operations share the threads, the time
+     * limit and the concurrency of the scope.
+     */
+    get ntheory() {
+        return this.#ntheory ??= new NumberTheory_js_1.NumberTheory(this.context);
+    }
+    /**
+     * The polynomials: their greatest common divisor, least common multiple, resultant and discriminant, exactly. Its
+     * asynchronous operations share the threads, the time limit and the concurrency of the scope.
+     */
+    get poly() {
+        return this.#poly ??= new Polynomials_js_1.Polynomials(this.context);
+    }
+    /**
+     * The numeric linear algebra (on Eigen): matrices of zeros, identities, rotations; products, norms; the solutions
+     * of linear systems, least squares, inverses, determinants, ranks, decompositions, functions of matrices, sparse
+     * matrices.
+     */
+    get linalg() {
+        return this.#linalg ??= new LinearAlgebra_js_1.LinearAlgebra(this.context);
+    }
+    /**
+     * The statistics of values (arrays of numbers, or `Float64Array`s): sums, means, medians, modes, variances,
+     * quantiles, covariances, correlations; the probability distributions (`normal()` … `hypergeometric()`) and a
+     * generator of random numbers (`random()`).
+     */
+    get stats() {
+        return this.#stats ??= new Statistics_js_1.Statistics(this.context);
+    }
+    /**
+     * The numeric solutions of equations, the integrals and the differential equations: the roots of polynomials, a
+     * root of a function, a solution of a system of nonlinear equations, the integral of a function, the solution of
+     * ordinary differential equations.
+     */
+    get numeric() {
+        return this.#numeric ??= new Numeric_js_1.Numeric(this.context);
+    }
+    /**
+     * Parse a formula: an expression (`x^2 - 5x + 6`), an equation (`x^2 = 4`), an inequality (`x^2 < 4`), or a matrix
+     * (`[1, x; x^2, 2]`, `[1, 2; 3, 4] * [x; y]`, `inv(…)`); `det(…)` and `trace(…)` of a matrix are expressions.
+     * @param text The formula.
+     */
+    parse(text) {
+        if (typeof text !== 'string')
+            throw new MathArgumentException_js_1.MathArgumentException('The formula is not a string');
+        const parsed = (0, Expression_js_1.parsedOf)(this.context, text);
+        if (parsed.kind === 'matrix')
+            return new ExpressionMatrix_js_1.ExpressionMatrix(this.context, parsed.matrix.matrix, parsed.matrix.rows, parsed.matrix.columns);
+        return (0, Expression_js_1.formulaOf)(this.context, parsed);
+    }
+    /**
+     * A matrix of expressions: of its rows (expressions, numbers or formulas: `[[1, 'x'], ['x^2', 2]]`), of a formula
+     * of a matrix (`'[1, x; x^2, 2]'`), or of a matrix of numbers (each the decimal it prints as).
+     * @param value The rows, the formula, or the matrix.
+     */
+    expressionMatrix(value) {
+        return (0, ExpressionMatrix_js_1.expressionMatrixOf)(this.context, value);
+    }
+    /**
+     * An interval of real numbers: empty when the start is after the end, a value when they are equal and included.
+     * @param start The start (`-inf` for none): an exact real number, an expression or a formula.
+     * @param end The end (`inf` for none).
+     * @param options Whether the ends are excluded (both included by default).
+     */
+    interval(start, end, options) {
+        return (0, MathSet_js_1.intervalOf)(this.context, start, end, options);
+    }
+    /**
+     * A finite set of values: each one once, the real ones sorted, then the others as they are given.
+     * @param values The values: expressions, numbers or formulas.
+     */
+    finiteSet(values) {
+        if (!Array.isArray(values))
+            throw new MathArgumentException_js_1.MathArgumentException('The values of a set are an array');
+        return (0, MathSet_js_1.finiteSetOf)(this.context, values);
+    }
+    /**
+     * The Jacobian matrix of expressions by variables: a row for each expression, its derivatives by the variables.
+     * @param expressions The expressions (or formulas).
+     * @param variables The variables.
+     */
+    jacobian(expressions, variables) {
+        if (!Array.isArray(expressions) || !Array.isArray(variables))
+            throw new MathArgumentException_js_1.MathArgumentException('The expressions and the variables are arrays');
+        const result = this.context.run('matrix', ['jacobian', [], expressions.map((expression) => (0, Expression_js_1.handleOf)(this.context, expression)), [], variables]);
+        return new ExpressionMatrix_js_1.ExpressionMatrix(this.context, result.matrix.matrix, result.matrix.rows, result.matrix.columns);
+    }
+    /**
+     * An expression: a formula parsed (an equation is an error), or the exact value of a number (`0.1` is `1/10`).
+     * @param value The formula, or the number.
+     */
+    expression(value) {
+        if (value instanceof Expression_js_1.Expression)
+            return value;
+        if (typeof value === 'string')
+            return (0, Expression_js_1.expressionOf)(this.context, value);
+        return new Expression_js_1.Expression(this.context, (0, Expression_js_1.handleOf)(this.context, value));
+    }
+    /**
+     * A decimal of a precision: a value rounded to that many significant digits (halves to even). A number is read by
+     * its shortest representation (`0.1` is 0.1), a string as a decimal number (`'19.99'`); an expression is computed,
+     * as `toDecimal()` does.
+     * @param value A decimal number (a number, a bigint, a string, a decimal) or an expression without variables.
+     * @param options The precision: the one of the scope by default.
+     */
+    decimal(value, options = {}) {
+        const precision = options.precision ?? this.context.settings.precision;
+        if (!Number.isInteger(precision) || precision < 1 || precision > 100000)
+            throw new MathArgumentException_js_1.MathArgumentException('The precision is an integer from 1 to 100000');
+        if (value instanceof Expression_js_1.Expression)
+            return new Decimal_js_1.Decimal(value.toDecimal(precision), precision);
+        return new Decimal_js_1.Decimal((0, Native_js_1.nativeCall)((native) => native.run('decimalOperation', ['round', precision, (0, Decimal_js_1.decimalText)(value)])), precision);
+    }
+    /**
+     * A value with units: of a formula of units (`'5 cm + 2 inch'`, `'9.8 m/s^2'`), or of a number and its units
+     * (`unit(5, 'cm')`); a number alone has no units. The names of a formula of units are units (of the table, with
+     * their prefixes, or of the options), `pi`, `e` and `i`.
+     * @param value The formula of units, or the number (a number, an expression, a formula of `expression()`).
+     * @param units The units of the number: a formula of units without a number (`'m/s^2'`).
+     */
+    unit(value, units) {
+        return (0, Unit_js_1.unitOf)(this.context, value, units);
+    }
+    /**
+     * A physical constant with its units (`constant('speedOfLight')` is `299792458 m / s`): the values of CODATA 2022,
+     * those that the SI defines exactly are their exact formulas (`reducedPlanckConstant` is `6.62607015e-34/(2pi) J
+     * s`).
+     * @param name The name of the constant.
+     */
+    constant(name) {
+        return (0, Unit_js_1.constantOf)(this.context, name);
+    }
+    /**
+     * A matrix of numbers: of its rows (`[[1, 2], [3, 4]]`), or a copy of a matrix.
+     * @param value The rows, or a matrix.
+     */
+    matrix(value) {
+        return value instanceof Matrix_js_1.Matrix ? value.clone() : (0, Matrix_js_1.matrixOf)(value);
+    }
+    /**
+     * An equation: a formula with `=` parsed.
+     * @param text The formula.
+     */
+    equation(text) {
+        const formula = this.parse(text);
+        if (!(formula instanceof Expression_js_1.Equation))
+            throw new MathSyntaxException_js_1.MathSyntaxException(`An equation (with =) is expected: ${text}`);
+        return formula;
+    }
+    /**
+     * A scope over this one, its definitions added: they are used by the formulas parsed by it, and replace the ones
+     * of the same name.
+     * @param definitions A body by signature: `{'h(x)': 'f(x) + 1'}`.
+     */
+    with(definitions) {
+        return new MathScope(this.context.derive(definitions));
+    }
+    /**
+     * The solutions of a system of linear equations: none (an empty array), or one, with the values of the variables
+     * it determines.
+     * @param equations The equations: formulas, equations, or expressions equal to zero.
+     * @param variables The variables to solve for.
+     */
+    solve(equations, variables) {
+        return this.#solutions(this.context.run('solveLinear', this.#system(equations, variables)));
+    }
+    /**
+     * `solve()` in the threads of the addon.
+     * @param equations The equations: formulas, equations, or expressions equal to zero.
+     * @param variables The variables to solve for.
+     * @param options Its cancellation, its time limit.
+     */
+    async solveAsync(equations, variables, options) {
+        return this.#solutions(await this.context.runAsync('solveLinear', this.#system(equations, variables), options));
+    }
+    /**
+     * The common subexpressions of expressions (common subexpression elimination): the parts met more than once,
+     * named, and the expressions rewritten with them. Printed with `toJavaScript()` or `toC()`, the result is code that
+     * computes each part only once.
+     * @param expressions The expressions: expressions, numbers or formulas.
+     * @param options The prefix of the names.
+     * @example
+     * ```typescript
+     * import {math} from '@lakutata/math'
+     *
+     * function shared(): string {
+     *     const {replacements, expressions} = math.cse(['sin(x + y)^2 + x + y', 'cos(x + y)'])
+     *     //x0 = x + y; the expressions: x0 + sin(x0)^2, cos(x0)
+     *     const lines: string[] = replacements.map(({name, value}) => `const ${name} = ${value.toJavaScript()}`)
+     *     return [...lines, `return [${expressions.map((expression) => expression.toJavaScript()).join(', ')}]`].join('\n')
+     * }
+     * ```
+     */
+    cse(expressions, options) {
+        return this.#common(this.context.run('cse', this.#cseArguments(expressions, options)));
+    }
+    /**
+     * `cse()` in the threads of the addon.
+     * @param expressions The expressions: expressions, numbers or formulas.
+     * @param options The prefix of the names, the cancellation, the time limit.
+     */
+    async cseAsync(expressions, options) {
+        return this.#common(await this.context.runAsync('cse', this.#cseArguments(expressions, options), options));
+    }
+    #cseArguments(expressions, options) {
+        if (!Array.isArray(expressions))
+            throw new MathArgumentException_js_1.MathArgumentException('The expressions are an array');
+        return [expressions.map((expression) => (0, Expression_js_1.handleOf)(this.context, expression)), options?.prefix ?? 'x'];
+    }
+    #common(result) {
+        return {
+            replacements: result.replacements.map(({ name, value }) => ({ name: name, value: new Expression_js_1.Expression(this.context, value) })),
+            expressions: result.expressions.map((handle) => new Expression_js_1.Expression(this.context, handle))
+        };
+    }
+    #system(equations, variables) {
+        if (!Array.isArray(equations) || !Array.isArray(variables))
+            throw new MathArgumentException_js_1.MathArgumentException('The equations and the variables are arrays');
+        return [equations.map((equation) => (0, Expression_js_1.equationHandleOf)(this.context, equation)), variables];
+    }
+    #solutions(result) {
+        if (result.kind === 'empty')
+            return [];
+        const solution = {};
+        for (const [name, value] of Object.entries(result.values))
+            solution[name] = new Expression_js_1.Expression(this.context, value);
+        return [solution];
+    }
+}
+exports.MathScope = MathScope;
+/**
+ * A scope of definitions and settings (`MathScope`) with these options: the package exports the one made with the
+ * default options, `math`, and its functions (`expression()`, `linalg`…). Its options are checked
+ * (`MathArgumentException`).
+ * @param options Its definitions, the precision of its decimals, the time limit and the concurrency of its
+ * asynchronous operations: all of them have a default value.
+ * @example
+ * ```typescript
+ * import {createMath, type MathScope} from '@lakutata/math'
+ *
+ * const finance: MathScope = createMath({definitions: {'vat(x)': 'x * 0.2'}, precision: 40, timeout: 5000})
+ * console.log(finance.expression('vat(150)').toNumber())                  //30
+ * ```
+ */
+function createMath(options = {}) {
+    if (typeof options !== 'object' || options === null)
+        throw new MathArgumentException_js_1.MathArgumentException('The options are an object');
+    const precision = options.precision ?? 32, timeout = options.timeout ?? 0;
+    if (!Number.isInteger(precision) || precision < 1 || precision > 100000)
+        throw new MathArgumentException_js_1.MathArgumentException('The precision is an integer from 1 to 100000');
+    if (typeof timeout !== 'number' || !(timeout >= 0))
+        throw new MathArgumentException_js_1.MathArgumentException('The time limit is a number of milliseconds, 0 or more');
+    const concurrency = options.concurrency ?? Native_js_1.native.versions().threads;
+    if (!Number.isInteger(concurrency) || concurrency < 1)
+        throw new MathArgumentException_js_1.MathArgumentException('The concurrency is an integer of 1 or more');
+    const definitions = options.definitions ?? {};
+    if (typeof definitions !== 'object' || definitions === null || Object.values(definitions).some((body) => typeof body !== 'string' && typeof body !== 'number')) {
+        throw new MathArgumentException_js_1.MathArgumentException('The definitions are an object of bodies (strings or numbers) by signature');
+    }
+    const units = new Unit_js_1.UnitSystem(options.units ?? {});
+    const scope = (0, Native_js_1.nativeCall)((addon) => addon.scope(null, (0, Context_js_1.definitionsOf)(definitions)));
+    const context = new Context_js_1.Context(scope, { precision: precision, timeout: timeout, concurrency: concurrency }, new Context_js_1.AsyncTracker(concurrency), units);
+    units.validate(context);
+    return new MathScope(context);
+}