@lakutata/math 0.0.0-stage → 3.1.3

package/dist/types/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/types/lib/MathSet.d.ts

@@ -0,0 +1,139 @@
+import type { Context } from './Context.js';
+import { Expression, type Value } from './Expression.js';
+/**
+ * An interval of a set of numbers: its ends, exact (`-inf` and `inf` where it has none), and whether each one is
+ * excluded
+ */
+export interface SetInterval {
+    /**
+     * Its start (`-inf` without one).
+     */
+    start: Expression;
+    /**
+     * Its end (`inf` without one).
+     */
+    end: Expression;
+    /**
+     * Whether the start is excluded.
+     */
+    startOpen: boolean;
+    /**
+     * Whether the end is excluded.
+     */
+    endOpen: boolean;
+}
+/**
+ * What a set is: empty, some values, intervals of real numbers (with values apart from them), every value, or a set
+ * described in text, which the operations do not take
+ */
+export type MathSetKind = 'empty' | 'finite' | 'intervals' | 'all' | 'other';
+/**
+ * Whether the ends of an interval are excluded: both are included by default
+ */
+export interface IntervalOptions {
+    /**
+     * Whether the start is excluded.
+     */
+    startOpen?: boolean;
+    /**
+     * Whether the end is excluded.
+     */
+    endOpen?: boolean;
+}
+/**
+ * A set of numbers: some values, intervals of real numbers with exact ends, every value, or a set described in text
+ * (the periodic solutions of an equation). Its intervals are sorted and apart, its values outside them (the real ones
+ * sorted). It is immutable: each operation gives a new set. The operations compare the ends exactly (`compare()`): a
+ * set with variables in its ends throws `MathNotSupportedException` where they cannot be ordered.
+ * @example
+ * ```typescript
+ * import {finiteSet, interval} from '@lakutata/math'
+ *
+ * const set = interval(0, 2, {endOpen: true}).union(finiteSet([3]))
+ * console.log(set.toString())                    //[0, 2) ∪ {3}
+ * console.log(set.complement().toString())       //(-inf, 0) ∪ [2, 3) ∪ (3, inf)
+ * console.log(set.contains('sqrt(2)'))           //true
+ * ```
+ */
+export declare class MathSet {
+    #private;
+    protected readonly context: Context;
+    readonly values: readonly Expression[];
+    readonly intervals: readonly SetInterval[];
+    readonly text?: string | undefined;
+    /**
+     * What the set is.
+     */
+    readonly kind: MathSetKind;
+    /**
+     * A set of values and intervals, as they are given (sorted and apart: `interval()`, `finiteSet()` and the
+     * operations make them so).
+     * @param context The context of the formulas.
+     * @param values The values outside the intervals.
+     * @param intervals The intervals.
+     * @param kind What the set is (from the values and the intervals by default).
+     * @param text The description of a set of the kind `other`.
+     */
+    constructor(context: Context, values?: readonly Expression[], intervals?: readonly SetInterval[], kind?: MathSetKind, text?: string | undefined);
+    /**
+     * Whether the set has no element.
+     */
+    isEmpty(): boolean;
+    /**
+     * Whether a value is in the set: `undefined` where it is not known (a value with variables, a set of the kind
+     * `other`).
+     * @param value The value: an expression, a number or a formula.
+     */
+    contains(value: Value): boolean | undefined;
+    /**
+     * The union with another set.
+     * @param other The other set.
+     */
+    union(other: MathSet): MathSet;
+    /**
+     * The intersection with another set.
+     * @param other The other set.
+     */
+    intersect(other: MathSet): MathSet;
+    /**
+     * The complement in the real numbers: the values of the set that are not real play no part in it.
+     */
+    complement(): MathSet;
+    /**
+     * The elements of the set that are not in another one.
+     * @param other The other set.
+     */
+    difference(other: MathSet): MathSet;
+    /**
+     * Whether the set has the same elements as another one.
+     * @param other The other set.
+     */
+    equals(other: MathSet): boolean;
+    /**
+     * The set in the notation of intervals: `(-inf, -1] ∪ {0} ∪ [1, 2)`; `{}` for the empty set, `every value`, or the
+     * description of a set of the kind `other`.
+     */
+    toString(): string;
+    /**
+     * The set, for `JSON.stringify()`.
+     */
+    toJSON(): string;
+    /**
+     * The LaTeX of the set: `\left(-\infty, -1\right] \cup \left\{0\right\}`, `\emptyset`.
+     */
+    toTeX(): string;
+}
+/**
+ * An interval of real numbers, in a context: empty when the start is after the end, a value when they are equal.
+ * @param context The context of the formulas.
+ * @param start The start (`-inf` for none).
+ * @param end The end (`inf` for none).
+ * @param options Whether the ends are excluded.
+ */
+export declare function intervalOf(context: Context, start: Value, end: Value, options?: IntervalOptions): MathSet;
+/**
+ * A finite set of values, in a context: each one once, the real ones sorted, then the others as they are given.
+ * @param context The context of the formulas.
+ * @param values The values.
+ */
+export declare function finiteSetOf(context: Context, values: readonly Value[]): MathSet;

package/dist/types/lib/Matrix.d.ts

@@ -0,0 +1,212 @@
+/**
+ * A value given where a matrix is expected: a matrix, or its rows (`[[1, 2], [3, 4]]`; `[]` is a matrix of no rows and
+ * no columns, `[[]]` one of a row and no columns)
+ */
+export type MatrixValue = Matrix | number[][];
+/**
+ * A value given where a vector is expected: a `Float64Array`, or an array of numbers (`[]` is a vector of no elements,
+ * where a vector or a matrix may be given)
+ */
+export type VectorValue = Float64Array | number[];
+/**
+ * A matrix as the addon reads and gives it: its rows, its columns, its elements row by row
+ */
+export type NativeMatrix = [number, number, Float64Array];
+/**
+ * The matrix of a value: a matrix itself, or one made of its rows
+ * @param value
+ * @param what The name of the value in the errors.
+ */
+export declare function matrixOf(value: MatrixValue, what?: string): Matrix;
+/**
+ * The elements of a vector as a `Float64Array` (the array itself when it is one)
+ * @param value
+ * @param what The name of the value in the errors.
+ */
+export declare function vectorOf(value: VectorValue, what?: string): Float64Array;
+/**
+ * Whether a value given is a vector (a `Float64Array`, or an array of numbers) rather than a matrix
+ * @param value
+ */
+export declare function isVector(value: unknown): value is VectorValue;
+/**
+ * A matrix as the addon reads it
+ * @param matrix
+ */
+export declare function nativeOf(matrix: Matrix): NativeMatrix;
+/**
+ * A vector as the addon reads it: a matrix of one column
+ * @param vector
+ */
+export declare function nativeColumnOf(vector: Float64Array): NativeMatrix;
+/**
+ * A matrix of the addon
+ * @param result
+ */
+export declare function matrixFrom(result: NativeMatrix): Matrix;
+/**
+ * An operation of the linear algebra in the thread of JavaScript
+ * @param operation
+ * @param matrices
+ * @param numbers
+ * @param option
+ */
+export declare function linalgRun(operation: string, matrices: NativeMatrix[], numbers?: number[], option?: string): NativeMatrix[];
+/**
+ * A matrix of numbers (doubles): its elements in a `Float64Array`, row by row, which the addon reads in place. Its
+ * operations never change it: they give new matrices; `set()` and the elements of `data` are the ways to fill one.
+ *
+ * Its products (`mul()`) are computed by Eigen; the operations of one element at a time (`add()`, `transpose()`,
+ * `map()`…) in JavaScript. A matrix times a vector (a `Float64Array`, or an array of numbers) is a vector. The
+ * decompositions, the inverse and the solutions of linear systems are in `math.linalg`.
+ * @example
+ * ```typescript
+ * import {math, Matrix} from '@lakutata/math'
+ *
+ * const a: Matrix = math.matrix([[4, 1], [2, 3]])
+ * a.mul(a).toString()                               //[18, 7; 14, 11]
+ * a.mul([1, 1])                                     //Float64Array [5, 5]
+ * a.transpose().add(1).toArray()                    //[[5, 3], [2, 4]]
+ * math.linalg.inverse(a).toString()                 //[0.3, -0.1; -0.2, 0.4]
+ * ```
+ */
+export declare class Matrix {
+    #private;
+    readonly rows: number;
+    readonly columns: number;
+    /**
+     * The elements, row by row: the element of row i and column j is `data[i * columns + j]`.
+     */
+    readonly data: Float64Array;
+    /**
+     * A matrix of zeros, or of elements given.
+     * @param rows The rows, an integer of 0 or more.
+     * @param columns The columns, an integer of 0 or more.
+     * @param data Its elements, row by row: `rows * columns` of them, used as they are (not copied). Zeros by default.
+     */
+    constructor(rows: number, columns: number, data?: Float64Array);
+    /**
+     * The element of a row and a column (from 0).
+     * @param row The row.
+     * @param column The column.
+     */
+    get(row: number, column: number): number;
+    /**
+     * Set the element of a row and a column (from 0): the matrix changes.
+     * @param row The row.
+     * @param column The column.
+     * @param value The value.
+     */
+    set(row: number, column: number, value: number): this;
+    /**
+     * The elements of a row (from 0), copied.
+     * @param row The row.
+     */
+    row(row: number): Float64Array;
+    /**
+     * The elements of a column (from 0), copied.
+     * @param column The column.
+     */
+    column(column: number): Float64Array;
+    /**
+     * The elements of the diagonal: of the rows and columns of the same index.
+     */
+    diagonal(): Float64Array;
+    /**
+     * The rows from `rowStart` to `rowEnd` (excluded) and the columns from `columnStart` to `columnEnd` (excluded).
+     * @param rowStart The first row: 0 by default.
+     * @param rowEnd The row after the last: all of them by default.
+     * @param columnStart The first column: 0 by default.
+     * @param columnEnd The column after the last: all of them by default.
+     */
+    submatrix(rowStart?: number, rowEnd?: number, columnStart?: number, columnEnd?: number): Matrix;
+    /**
+     * The same elements, row by row, in other dimensions of the same number of elements.
+     * @param rows The rows.
+     * @param columns The columns.
+     */
+    reshape(rows: number, columns: number): Matrix;
+    /**
+     * The transpose: the rows become the columns.
+     */
+    transpose(): Matrix;
+    /**
+     * The sum of the matrix and another one of its size, or a number added to each element.
+     * @param other A matrix (or its rows), or a number.
+     */
+    add(other: MatrixValue | number): Matrix;
+    /**
+     * The difference of the matrix and another one of its size, or a number subtracted from each element.
+     * @param other A matrix (or its rows), or a number.
+     */
+    sub(other: MatrixValue | number): Matrix;
+    /**
+     * The product of the matrix and a matrix (computed by Eigen), a vector (a vector), or a number (each element
+     * times it). The products of large matrices take long: `math.linalg.multiplyAsync()` computes them in the threads
+     * of the addon.
+     * @param other A matrix (or its rows), a vector, or a number.
+     */
+    mul(other: number | MatrixValue): Matrix;
+    mul(other: VectorValue): Float64Array;
+    mul(other: number | MatrixValue | VectorValue): Matrix | Float64Array;
+    /**
+     * Each element divided by a number.
+     * @param divisor The number.
+     */
+    div(divisor: number): Matrix;
+    /**
+     * The opposite: each element negated.
+     */
+    neg(): Matrix;
+    /**
+     * The products of the elements of the same place in two matrices of the same size.
+     * @param other A matrix (or its rows).
+     */
+    multiplyElements(other: MatrixValue): Matrix;
+    /**
+     * The quotients of the elements of the same place in two matrices of the same size.
+     * @param other A matrix (or its rows).
+     */
+    divideElements(other: MatrixValue): Matrix;
+    /**
+     * Each element to a power (not the power of the matrix: that is `mul()` again, or `math.linalg.exponential()`).
+     * @param exponent The power.
+     */
+    powElements(exponent: number): Matrix;
+    /**
+     * A matrix of the values of a function of each element.
+     * @param transform The function of an element, its row and its column.
+     */
+    map(transform: (value: number, row: number, column: number) => number): Matrix;
+    /**
+     * The sum of the elements of the diagonal, of a square matrix.
+     */
+    trace(): number;
+    /**
+     * The Kronecker product: each element times the other matrix, as a block.
+     * @param other A matrix (or its rows).
+     */
+    kron(other: MatrixValue): Matrix;
+    /**
+     * Whether a matrix has the same size and elements: equal, or apart by at most a tolerance each.
+     * @param other A matrix (or its rows).
+     * @param tolerance The largest difference of two elements: 0 by default.
+     */
+    equals(other: MatrixValue, tolerance?: number): boolean;
+    /**
+     * A copy of the matrix.
+     */
+    clone(): Matrix;
+    /**
+     * The rows of the matrix as arrays of numbers.
+     */
+    toArray(): number[][];
+    /**
+     * The rows of the matrix, as `toArray()`: a matrix in JSON is its rows.
+     */
+    toJSON(): number[][];
+    /**
+     * The matrix written as in the formulas: its rows separated by semicolons (`[1, 2; 3, 4]`).
+     */
+    toString(): string;
+}