@lakutata/math 0.0.0-stage → 3.1.3

package/dist/esm/lib/LinearAlgebra.js

@@ -0,0 +1,708 @@
+import { MathArgumentException } from '../exceptions/MathArgumentException.js';
+import { isVector, linalgRun, Matrix, matrixFrom, matrixOf, nativeColumnOf, nativeOf, vectorOf } from './Matrix.js';
+import { nativeSparseOf, SparseMatrix, sparseOfEntries, sparseOfMatrix, sparseRun } from './SparseMatrix.js';
+function operandOf(value, what) {
+    if (isVector(value))
+        return { native: nativeColumnOf(vectorOf(value, what)), vector: true };
+    return { native: nativeOf(matrixOf(value, what)), vector: false };
+}
+function shapeOf(result, vector) {
+    return vector ? result[2] : matrixFrom(result);
+}
+function sameLength(u, v, operation) {
+    if (u.length !== v.length)
+        throw new MathArgumentException(`The vectors of ${operation} differ in length: ${u.length} and ${v.length}`);
+}
+/**
+ * The rank of a matrix of singular values: those above a tolerance, by default the largest one times
+ * `max(rows, columns)` times the machine epsilon (NumPy's)
+ * @param values
+ * @param rows
+ * @param columns
+ * @param tolerance
+ */
+function rankOf(values, rows, columns, tolerance) {
+    const threshold = tolerance ?? (values.length ? values[0] * Math.max(rows, columns) * Number.EPSILON : 0);
+    return values.filter((value) => value > threshold).length;
+}
+/**
+ * The Euclidean norm of values, scaled by the largest one (no overflow of the squares of large values)
+ * @param values
+ */
+function euclidean(values) {
+    let largest = 0;
+    for (const value of values)
+        largest = Math.max(largest, Math.abs(value));
+    if (largest === 0 || !Number.isFinite(largest))
+        return largest;
+    let sum = 0;
+    for (const value of values)
+        sum += (value / largest) ** 2;
+    return largest * Math.sqrt(sum);
+}
+function sparseMatrixOf(value) {
+    return value instanceof SparseMatrix ? value : sparseOfMatrix(matrixOf(value));
+}
+//The right side and the guess of an iterative solver, its tolerance and its largest number of iterations
+function iterativeOf(a, b, iterative) {
+    const tolerance = iterative?.tolerance ?? 1e-10;
+    const iterations = iterative?.maxIterations ?? globalThis.Math.min(10 * a.rows, 2147483647);
+    if (typeof tolerance !== 'number' || !(tolerance >= 0) || !Number.isFinite(tolerance))
+        throw new MathArgumentException('The tolerance is a number of 0 or more');
+    if (!Number.isInteger(iterations) || iterations < 0 || iterations > 2147483647)
+        throw new MathArgumentException('The largest number of iterations is an integer from 0 to 2^31 - 1');
+    const dense = [nativeColumnOf(vectorOf(b, 'The right side'))];
+    if (iterative?.guess !== undefined)
+        dense.push(nativeColumnOf(vectorOf(iterative.guess, 'The guess')));
+    return { dense, numbers: [tolerance, iterations] };
+}
+function iterativeSolutionOf(results) {
+    const [solution, outcome] = results[0];
+    return { solution: solution[2], iterations: outcome[2][0], error: outcome[2][1], converged: outcome[2][2] === 1 };
+}
+function luOf(results) {
+    return { lower: matrixFrom(results[0]), upper: matrixFrom(results[1]), permutation: Array.from(results[2][2]) };
+}
+function qrOf(results) {
+    return { q: matrixFrom(results[0]), r: matrixFrom(results[1]) };
+}
+function svdOf(results) {
+    return { u: matrixFrom(results[0]), singularValues: results[1][2], v: matrixFrom(results[2]) };
+}
+function eigenOf(results) {
+    return { values: { re: results[0][2], im: results[1][2] }, vectors: { re: matrixFrom(results[2]), im: matrixFrom(results[3]) } };
+}
+function symmetricEigenOf(results) {
+    return { values: results[0][2], vectors: matrixFrom(results[1]) };
+}
+function schurOf(results) {
+    return { u: matrixFrom(results[0]), t: matrixFrom(results[1]) };
+}
+function toleranceOf(tolerance) {
+    if (tolerance === undefined)
+        return [];
+    if (typeof tolerance !== 'number' || !(tolerance >= 0))
+        throw new MathArgumentException('A tolerance is a number of 0 or more');
+    return [tolerance];
+}
+function conditionOf(values) {
+    if (!values.length)
+        return 0;
+    const smallest = values[values.length - 1];
+    return smallest === 0 ? Infinity : values[0] / smallest;
+}
+/**
+ * The numeric linear algebra of matrices of doubles (`Matrix`) and vectors (`Float64Array`), on Eigen: matrices of
+ * zeros, of ones, identities, diagonals, rotations; products, dot and cross products; norms; the solutions of linear
+ * systems, least squares, inverses, determinants, ranks, condition numbers and singular values; the decompositions (LU,
+ * QR, Cholesky, singular values, eigenvalues, Schur) and the pseudo-inverse; the exponential and the square root of a
+ * matrix; the Sylvester and Lyapunov equations; sparse matrices (`SparseMatrix`) and their systems, by the sparse LU
+ * decomposition, the conjugate gradient and BiCGSTAB. It is `MathScope.linalg`; the package exports the one of `math`
+ * as `linalg`.
+ *
+ * Where a vector is expected, a `Float64Array` or an array of numbers is given; where a matrix is, a `Matrix` or its
+ * rows (`[[1, 2], [3, 4]]`). A system with a vector on its right side has a vector for solution, one with a matrix (one
+ * right side by column) a matrix.
+ *
+ * For `solve()` and `inverse()`, a matrix is singular when its LU decomposition with partial pivoting meets a pivot of
+ * exactly 0, as in NumPy: a matrix close to singular gives large values, not an error; `condition()` tells how close it
+ * is. A singular matrix throws `MathDomainException`, matrices of the wrong dimensions `MathArgumentException`.
+ *
+ * The operations that take long on large matrices have an asynchronous version (`solveAsync()`…), in the threads of the
+ * addon. A computation of Eigen cannot be stopped halfway: at the time limit or the cancellation, the promise is
+ * rejected, and its thread finishes that computation before it is free again.
+ * @example
+ * ```typescript
+ * import {math} from '@lakutata/math'
+ *
+ * const a = math.matrix([[4, 1], [2, 3]])
+ * math.linalg.solve(a, [5, 5])                         //Float64Array [1, 1]
+ * math.linalg.determinant(a)                           //10
+ * math.linalg.inverse(a).toString()                    //[0.3, -0.1; -0.2, 0.4]
+ * math.linalg.rank([[1, 2], [2, 4]])                   //1
+ * math.linalg.norm([3, 4])                             //5
+ * const x = await math.linalg.solveAsync(math.linalg.identity(500), new Float64Array(500).fill(1))
+ * ```
+ */
+export class LinearAlgebra {
+    constructor(context) {
+        this.context = context;
+    }
+    async #runAsync(operation, matrices, options, numbers = [], option = '') {
+        //The elements copied at the call, before the operation waits for its turn: the matrices given may change then
+        const copies = matrices.map(([rows, columns, data]) => [rows, columns, data.slice()]);
+        return await this.context.runAsync('linalg', [operation, copies, numbers, option], options);
+    }
+    async #sparseAsync(operation, sparse, dense, options, numbers = []) {
+        //Copied at the call too, the structures of the sparse matrices as their values
+        const sparseCopies = sparse.map(([rows, columns, pointers, indices, values]) => [rows, columns, pointers.slice(), indices.slice(), values.slice()]);
+        const denseCopies = dense.map(([rows, columns, data]) => [rows, columns, data.slice()]);
+        return await this.context.runAsync('sparse', [operation, sparseCopies, denseCopies, numbers], options);
+    }
+    /**
+     * A matrix of zeros.
+     * @param rows The rows.
+     * @param columns The columns: as many as the rows by default.
+     */
+    zeros(rows, columns = rows) {
+        return new Matrix(rows, columns);
+    }
+    /**
+     * A matrix of ones.
+     * @param rows The rows.
+     * @param columns The columns: as many as the rows by default.
+     */
+    ones(rows, columns = rows) {
+        const matrix = new Matrix(rows, columns);
+        matrix.data.fill(1);
+        return matrix;
+    }
+    /**
+     * The identity matrix: ones on the diagonal, zeros elsewhere.
+     * @param size The rows and the columns.
+     */
+    identity(size) {
+        const matrix = new Matrix(size, size);
+        for (let i = 0; i < size; i++)
+            matrix.data[i * size + i] = 1;
+        return matrix;
+    }
+    /**
+     * A square matrix of values on its diagonal, zeros elsewhere.
+     * @param values The diagonal.
+     */
+    diagonal(values) {
+        const diagonal = vectorOf(values, 'The diagonal');
+        const matrix = new Matrix(diagonal.length, diagonal.length);
+        diagonal.forEach((value, i) => {
+            matrix.data[i * diagonal.length + i] = value;
+        });
+        return matrix;
+    }
+    /**
+     * A matrix of its rows.
+     * @param rows The rows: vectors of the same length.
+     */
+    fromRows(rows) {
+        return matrixOf(rows.map((row) => Array.from(vectorOf(row, 'A row'))), 'The rows');
+    }
+    /**
+     * A matrix of its columns.
+     * @param columns The columns: vectors of the same length.
+     */
+    fromColumns(columns) {
+        return this.fromRows(columns).transpose();
+    }
+    /**
+     * A matrix of the values of a function of the row and the column of each element (from 0).
+     * @param rows The rows.
+     * @param columns The columns.
+     * @param element The value of an element of a row and a column.
+     */
+    fromFunction(rows, columns, element) {
+        return new Matrix(rows, columns).map((_, row, column) => element(row, column));
+    }
+    /**
+     * Matrices put together: one below the other (`'vertical'`, of the same number of columns) or side by side
+     * (`'horizontal'`, of the same number of rows).
+     * @param matrices The matrices (or their rows).
+     * @param direction `'vertical'` by default.
+     */
+    concat(matrices, direction = 'vertical') {
+        if (direction !== 'vertical' && direction !== 'horizontal')
+            throw new MathArgumentException('Matrices are put together vertically or horizontally');
+        const list = matrices.map((matrix) => direction === 'vertical' ? matrixOf(matrix) : matrixOf(matrix).transpose());
+        if (!list.length)
+            return new Matrix(0, 0);
+        const columns = list[0].columns;
+        const different = list.find((matrix) => matrix.columns !== columns);
+        if (different)
+            throw new MathArgumentException(`Matrices put together ${direction}ly have the same number of ${direction === 'vertical' ? 'columns' : 'rows'}: ${columns} and ${different.columns}`);
+        const rows = list.reduce((sum, matrix) => sum + matrix.rows, 0);
+        const data = new Float64Array(rows * columns);
+        let offset = 0;
+        for (const matrix of list) {
+            data.set(matrix.data, offset);
+            offset += matrix.data.length;
+        }
+        const stacked = new Matrix(rows, columns, data);
+        return direction === 'vertical' ? stacked : stacked.transpose();
+    }
+    /**
+     * The matrix of a rotation: in the plane (2×2) of an angle, counterclockwise; in space (3×3) of an angle about an
+     * axis, counterclockwise looking from its end (the right-hand rule).
+     * @param angle The angle, in radians.
+     * @param axis The axis of a rotation in space: a vector of 3 elements, not 0.
+     */
+    rotation(angle, axis) {
+        const cos = Math.cos(angle), sin = Math.sin(angle);
+        if (axis === undefined)
+            return matrixOf([[cos, -sin], [sin, cos]]);
+        const u = vectorOf(axis, 'The axis');
+        const length = Math.hypot(...u);
+        if (u.length !== 3 || !(length > 0))
+            throw new MathArgumentException('The axis of a rotation in space is a vector of 3 elements, not 0');
+        const [x, y, z] = Array.from(u, (value) => value / length);
+        const c = 1 - cos;
+        return matrixOf([
+            [cos + x * x * c, x * y * c - z * sin, x * z * c + y * sin],
+            [y * x * c + z * sin, cos + y * y * c, y * z * c - x * sin],
+            [z * x * c - y * sin, z * y * c + x * sin, cos + z * z * c]
+        ]);
+    }
+    /**
+     * The dot product of two vectors of the same length.
+     * @param u A vector.
+     * @param v A vector.
+     */
+    dot(u, v) {
+        const a = vectorOf(u), b = vectorOf(v);
+        sameLength(a, b, 'a dot product');
+        let sum = 0;
+        for (let i = 0; i < a.length; i++)
+            sum += a[i] * b[i];
+        return sum;
+    }
+    /**
+     * The cross product of two vectors of 3 elements.
+     * @param u A vector.
+     * @param v A vector.
+     */
+    cross(u, v) {
+        const a = vectorOf(u), b = vectorOf(v);
+        if (a.length !== 3 || b.length !== 3)
+            throw new MathArgumentException('The cross product is of vectors of 3 elements');
+        return Float64Array.of(a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0]);
+    }
+    /**
+     * The outer product of two vectors: the matrix of the products of each element of `u` (its rows) by each one of
+     * `v` (its columns).
+     * @param u A vector.
+     * @param v A vector.
+     */
+    outer(u, v) {
+        const a = vectorOf(u), b = vectorOf(v);
+        return new Matrix(a.length, b.length).map((_, i, j) => a[i] * b[j]);
+    }
+    /**
+     * The norm of a vector (the Euclidean one by default) or of a matrix (Frobenius's by default).
+     * @param value A vector or a matrix.
+     * @param kind For a vector, a number p of 1 or more, or `Infinity`; for a matrix, `'fro'`, 1, 2 or `Infinity`.
+     */
+    norm(value, kind) {
+        if (isVector(value))
+            return this.#vectorNorm(vectorOf(value), kind ?? 2);
+        const matrix = matrixOf(value);
+        if (kind === 2)
+            return this.singularValues(matrix)[0] ?? 0;
+        return this.#matrixNorm(matrix, kind ?? 'fro');
+    }
+    /**
+     * `norm()` in the threads of the addon: the 2-norm of a large matrix (its largest singular value).
+     * @param value A vector or a matrix.
+     * @param kind For a vector, a number p of 1 or more, or `Infinity`; for a matrix, `'fro'`, 1, 2 or `Infinity`.
+     * @param options Its cancellation, its time limit.
+     */
+    async normAsync(value, kind, options) {
+        if (isVector(value) || kind !== 2)
+            return this.norm(value, kind);
+        return (await this.singularValuesAsync(value, options))[0] ?? 0;
+    }
+    #vectorNorm(vector, kind) {
+        if (kind === Infinity)
+            return vector.reduce((largest, value) => Math.max(largest, Math.abs(value)), 0);
+        if (kind === 2)
+            return euclidean(vector);
+        if (typeof kind !== 'number' || !(kind >= 1))
+            throw new MathArgumentException('The norm of a vector is of a number p of 1 or more, or Infinity (\'fro\' is for matrices)');
+        return vector.reduce((sum, value) => sum + Math.abs(value) ** kind, 0) ** (1 / kind);
+    }
+    #matrixNorm(matrix, kind) {
+        if (kind === 'fro')
+            return euclidean(matrix.data);
+        if (kind !== 1 && kind !== Infinity)
+            throw new MathArgumentException('The norm of a matrix is \'fro\', 1, 2 or Infinity');
+        //The largest sum of the absolute values of a column (1) or of a row (Infinity)
+        const sums = new Float64Array(kind === 1 ? matrix.columns : matrix.rows);
+        for (let i = 0; i < matrix.rows; i++) {
+            for (let j = 0; j < matrix.columns; j++)
+                sums[kind === 1 ? j : i] += Math.abs(matrix.data[i * matrix.columns + j]);
+        }
+        return sums.reduce((largest, sum) => Math.max(largest, sum), 0);
+    }
+    multiply(a, b) {
+        return matrixOf(a).mul(b);
+    }
+    async multiplyAsync(a, b, options) {
+        const right = operandOf(b, 'The second factor');
+        return shapeOf((await this.#runAsync('multiply', [nativeOf(matrixOf(a)), right.native], options))[0], right.vector);
+    }
+    solve(a, b) {
+        const right = operandOf(b, 'The right side');
+        if (a instanceof SparseMatrix)
+            return shapeOf(sparseRun('solve', [nativeSparseOf(a)], [right.native])[0][0], right.vector);
+        return shapeOf(linalgRun('solve', [nativeOf(matrixOf(a)), right.native])[0], right.vector);
+    }
+    async solveAsync(a, b, options) {
+        const right = operandOf(b, 'The right side');
+        if (a instanceof SparseMatrix)
+            return shapeOf((await this.#sparseAsync('solve', [nativeSparseOf(a)], [right.native], options))[0][0], right.vector);
+        return shapeOf((await this.#runAsync('solve', [nativeOf(matrixOf(a)), right.native], options))[0], right.vector);
+    }
+    solveTriangular(a, b, triangle) {
+        const right = operandOf(b, 'The right side');
+        return shapeOf(linalgRun('solveTriangular', [nativeOf(matrixOf(a)), right.native], [], triangle)[0], right.vector);
+    }
+    leastSquares(a, b) {
+        const right = operandOf(b, 'The right side');
+        return shapeOf(linalgRun('leastSquares', [nativeOf(matrixOf(a)), right.native])[0], right.vector);
+    }
+    async leastSquaresAsync(a, b, options) {
+        const right = operandOf(b, 'The right side');
+        return shapeOf((await this.#runAsync('leastSquares', [nativeOf(matrixOf(a)), right.native], options))[0], right.vector);
+    }
+    /**
+     * The inverse of a square matrix, by its LU decomposition with partial pivoting. A singular matrix (a pivot of
+     * exactly 0) throws `MathDomainException`.
+     * @param a The matrix.
+     */
+    inverse(a) {
+        return matrixFrom(linalgRun('inverse', [nativeOf(matrixOf(a))])[0]);
+    }
+    /**
+     * `inverse()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async inverseAsync(a, options) {
+        return matrixFrom((await this.#runAsync('inverse', [nativeOf(matrixOf(a))], options))[0]);
+    }
+    /**
+     * The determinant of a square matrix, by its LU decomposition: 0 for a singular one, 1 for a matrix of no rows.
+     * @param a The matrix.
+     */
+    determinant(a) {
+        return linalgRun('determinant', [nativeOf(matrixOf(a))])[0][2][0];
+    }
+    /**
+     * `determinant()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async determinantAsync(a, options) {
+        return (await this.#runAsync('determinant', [nativeOf(matrixOf(a))], options))[0][2][0];
+    }
+    /**
+     * The singular values of a matrix, from the largest: `min(rows, columns)` of them.
+     * @param a The matrix.
+     */
+    singularValues(a) {
+        return linalgRun('singularValues', [nativeOf(matrixOf(a))])[0][2];
+    }
+    /**
+     * `singularValues()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async singularValuesAsync(a, options) {
+        return (await this.#runAsync('singularValues', [nativeOf(matrixOf(a))], options))[0][2];
+    }
+    /**
+     * The rank of a matrix: the number of its singular values above a tolerance, by default the largest one times
+     * `max(rows, columns)` times the machine epsilon (NumPy's `matrix_rank`).
+     * @param a The matrix.
+     * @param tolerance The singular values at or below it are 0.
+     */
+    rank(a, tolerance) {
+        const matrix = matrixOf(a);
+        return rankOf(this.singularValues(matrix), matrix.rows, matrix.columns, tolerance);
+    }
+    /**
+     * `rank()` in the threads of the addon.
+     * @param a The matrix.
+     * @param tolerance The singular values at or below it are 0.
+     * @param options Its cancellation, its time limit.
+     */
+    async rankAsync(a, tolerance, options) {
+        const matrix = matrixOf(a);
+        return rankOf(await this.singularValuesAsync(matrix, options), matrix.rows, matrix.columns, tolerance);
+    }
+    /**
+     * The condition number of a matrix in the 2-norm: its largest singular value over its smallest one (`Infinity`
+     * when that one is 0). The digits a solution of a system loses are about its logarithm in base 10.
+     * @param a The matrix.
+     */
+    condition(a) {
+        return conditionOf(this.singularValues(a));
+    }
+    /**
+     * `condition()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async conditionAsync(a, options) {
+        return conditionOf(await this.singularValuesAsync(a, options));
+    }
+    /**
+     * The LU decomposition of a square matrix with partial pivoting: `P A = L U`. It exists for a singular matrix too
+     * (a 0 on the diagonal of U).
+     * @param a The matrix.
+     */
+    lu(a) {
+        return luOf(linalgRun('lu', [nativeOf(matrixOf(a))]));
+    }
+    /**
+     * `lu()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async luAsync(a, options) {
+        return luOf(await this.#runAsync('lu', [nativeOf(matrixOf(a))], options));
+    }
+    /**
+     * The thin QR decomposition, by Householder reflections: `A = Q R`, Q of orthonormal columns, R upper triangular.
+     * Its signs are Eigen's: a column of Q and the row of R of the same index may both be negated in another library.
+     * @param a The matrix, of any size.
+     */
+    qr(a) {
+        return qrOf(linalgRun('qr', [nativeOf(matrixOf(a))]));
+    }
+    /**
+     * `qr()` in the threads of the addon.
+     * @param a The matrix, of any size.
+     * @param options Its cancellation, its time limit.
+     */
+    async qrAsync(a, options) {
+        return qrOf(await this.#runAsync('qr', [nativeOf(matrixOf(a))], options));
+    }
+    /**
+     * The Cholesky decomposition of a symmetric positive definite matrix: `A = L Lᵀ`, L lower triangular. Only the
+     * lower triangle of A is read (as NumPy's `cholesky`). A matrix that is not positive definite throws
+     * `MathDomainException`.
+     * @param a The matrix, square.
+     */
+    cholesky(a) {
+        return matrixFrom(linalgRun('cholesky', [nativeOf(matrixOf(a))])[0]);
+    }
+    /**
+     * `cholesky()` in the threads of the addon.
+     * @param a The matrix, square.
+     * @param options Its cancellation, its time limit.
+     */
+    async choleskyAsync(a, options) {
+        return matrixFrom((await this.#runAsync('cholesky', [nativeOf(matrixOf(a))], options))[0]);
+    }
+    /**
+     * The thin singular value decomposition: `A = U diag(s) Vᵀ`. The signs of a pair of singular vectors (a column of
+     * U, the column of V of the same index) are Eigen's: both may be negated in another library.
+     * @param a The matrix, of any size.
+     */
+    svd(a) {
+        return svdOf(linalgRun('svd', [nativeOf(matrixOf(a))]));
+    }
+    /**
+     * `svd()` in the threads of the addon.
+     * @param a The matrix, of any size.
+     * @param options Its cancellation, its time limit.
+     */
+    async svdAsync(a, options) {
+        return svdOf(await this.#runAsync('svd', [nativeOf(matrixOf(a))], options));
+    }
+    /**
+     * The eigenvalues and the eigenvectors of a square matrix, complex: their real and their imaginary parts. A matrix
+     * whose eigenvalues do not converge throws `MathNotSupportedException`.
+     * @param a The matrix.
+     */
+    eigen(a) {
+        return eigenOf(linalgRun('eigen', [nativeOf(matrixOf(a))]));
+    }
+    /**
+     * `eigen()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async eigenAsync(a, options) {
+        return eigenOf(await this.#runAsync('eigen', [nativeOf(matrixOf(a))], options));
+    }
+    /**
+     * The eigenvalues (real, ascending) and the orthonormal eigenvectors of a symmetric matrix. Only its lower
+     * triangle is read, as NumPy's `eigh`: the upper one is taken to be its transpose.
+     * @param a The matrix, square.
+     */
+    symmetricEigen(a) {
+        return symmetricEigenOf(linalgRun('symmetricEigen', [nativeOf(matrixOf(a))]));
+    }
+    /**
+     * `symmetricEigen()` in the threads of the addon.
+     * @param a The matrix, square.
+     * @param options Its cancellation, its time limit.
+     */
+    async symmetricEigenAsync(a, options) {
+        return symmetricEigenOf(await this.#runAsync('symmetricEigen', [nativeOf(matrixOf(a))], options));
+    }
+    /**
+     * The real Schur decomposition of a square matrix: `A = U T Uᵀ`, U orthogonal, T upper triangular but for blocks of
+     * 2×2 on its diagonal (a pair of complex eigenvalues each).
+     * @param a The matrix.
+     */
+    schur(a) {
+        return schurOf(linalgRun('schur', [nativeOf(matrixOf(a))]));
+    }
+    /**
+     * `schur()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async schurAsync(a, options) {
+        return schurOf(await this.#runAsync('schur', [nativeOf(matrixOf(a))], options));
+    }
+    /**
+     * The pseudo-inverse (Moore-Penrose) of a matrix of any size, by its singular values: those at or below a
+     * tolerance are 0, by default the largest one times `max(rows, columns)` times the machine epsilon (NumPy's `pinv`,
+     * and `rank()`). `pseudoInverse(a).mul(b)` is the least-squares solution of least norm, as `leastSquares(a, b)`.
+     * @param a The matrix.
+     * @param tolerance The singular values at or below it are taken as 0.
+     */
+    pseudoInverse(a, tolerance) {
+        return matrixFrom(linalgRun('pseudoInverse', [nativeOf(matrixOf(a))], toleranceOf(tolerance))[0]);
+    }
+    /**
+     * `pseudoInverse()` in the threads of the addon.
+     * @param a The matrix.
+     * @param tolerance The singular values at or below it are taken as 0.
+     * @param options Its cancellation, its time limit.
+     */
+    async pseudoInverseAsync(a, tolerance, options) {
+        return matrixFrom((await this.#runAsync('pseudoInverse', [nativeOf(matrixOf(a))], options, toleranceOf(tolerance)))[0]);
+    }
+    /**
+     * The exponential of a square matrix, `e^A`: by Padé approximants with scaling and squaring (Higham 2005); it is
+     * mathjs's `expm`. A matrix with an infinite or NaN element gives a matrix of NaN.
+     * @param a The matrix.
+     */
+    exponential(a) {
+        return matrixFrom(linalgRun('exponential', [nativeOf(matrixOf(a))])[0]);
+    }
+    /**
+     * `exponential()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async exponentialAsync(a, options) {
+        return matrixFrom((await this.#runAsync('exponential', [nativeOf(matrixOf(a))], options))[0]);
+    }
+    /**
+     * The principal square root of a square matrix: the X of `X X = A` whose eigenvalues have positive real parts, or
+     * are 0 where those of A are. It is real when A has no negative eigenvalue; otherwise, or when A has no principal
+     * square root at all (as `[[0, 1], [0, 0]]`), it throws `MathDomainException`.
+     * @param a The matrix.
+     */
+    squareRoot(a) {
+        return matrixFrom(linalgRun('squareRoot', [nativeOf(matrixOf(a))])[0]);
+    }
+    /**
+     * `squareRoot()` in the threads of the addon.
+     * @param a The matrix.
+     * @param options Its cancellation, its time limit.
+     */
+    async squareRootAsync(a, options) {
+        return matrixFrom((await this.#runAsync('squareRoot', [nativeOf(matrixOf(a))], options))[0]);
+    }
+    /**
+     * The solution X of the Sylvester equation `A X + X B = C` (as mathjs's `sylvester` and SciPy's
+     * `solve_sylvester`). It is unique when no eigenvalue of A is the opposite of an eigenvalue of B; otherwise it
+     * throws `MathDomainException`.
+     * @param a A, square (m×m).
+     * @param b B, square (n×n).
+     * @param c C, m×n.
+     */
+    sylvester(a, b, c) {
+        return matrixFrom(linalgRun('sylvester', [nativeOf(matrixOf(a)), nativeOf(matrixOf(b)), nativeOf(matrixOf(c))])[0]);
+    }
+    /**
+     * `sylvester()` in the threads of the addon.
+     * @param a A, square (m×m).
+     * @param b B, square (n×n).
+     * @param c C, m×n.
+     * @param options Its cancellation, its time limit.
+     */
+    async sylvesterAsync(a, b, c, options) {
+        return matrixFrom((await this.#runAsync('sylvester', [nativeOf(matrixOf(a)), nativeOf(matrixOf(b)), nativeOf(matrixOf(c))], options))[0]);
+    }
+    /**
+     * The solution P of the continuous Lyapunov equation `A P + P Aᵀ + Q = 0` (as mathjs's `lyap` and MATLAB's; SciPy's
+     * `solve_continuous_lyapunov(A, -Q)`). It is unique when no eigenvalues λ and μ of A, μ possibly λ itself, have
+     * λ + μ = 0, as when A is stable (the real parts of its eigenvalues are negative); otherwise it throws
+     * `MathDomainException`.
+     * @param a A, square.
+     * @param q Q, of the size of A.
+     */
+    lyapunov(a, q) {
+        return matrixFrom(linalgRun('lyapunov', [nativeOf(matrixOf(a)), nativeOf(matrixOf(q))])[0]);
+    }
+    /**
+     * `lyapunov()` in the threads of the addon.
+     * @param a A, square.
+     * @param q Q, of the size of A.
+     * @param options Its cancellation, its time limit.
+     */
+    async lyapunovAsync(a, q, options) {
+        return matrixFrom((await this.#runAsync('lyapunov', [nativeOf(matrixOf(a)), nativeOf(matrixOf(q))], options))[0]);
+    }
+    sparse(rowsOrMatrix, columns, entries) {
+        if (typeof rowsOrMatrix === 'number')
+            return sparseOfEntries(rowsOrMatrix, columns, entries);
+        return sparseOfMatrix(matrixOf(rowsOrMatrix));
+    }
+    /**
+     * The solution of `a x = b` by the conjugate gradient, with the diagonal of `a` as preconditioner (Eigen's
+     * `ConjugateGradient`, which reads the whole matrix). It is for a symmetric positive definite matrix, which is not
+     * checked: on another, it may not converge. It stops when the relative residual reaches the tolerance or after the
+     * largest number of iterations; `converged` tells which.
+     * @param a The matrix, square: sparse, or dense (made sparse).
+     * @param b The right side.
+     * @param iterative Its tolerance, its largest number of iterations, its first guess.
+     */
+    conjugateGradient(a, b, iterative) {
+        const matrix = sparseMatrixOf(a);
+        const { dense, numbers } = iterativeOf(matrix, b, iterative);
+        return iterativeSolutionOf(sparseRun('conjugateGradient', [nativeSparseOf(matrix)], dense, numbers));
+    }
+    /**
+     * `conjugateGradient()` in the threads of the addon.
+     * @param a The matrix, square: sparse, or dense (made sparse).
+     * @param b The right side.
+     * @param iterative Its tolerance, its largest number of iterations, its first guess.
+     * @param options Its cancellation, its time limit.
+     */
+    async conjugateGradientAsync(a, b, iterative, options) {
+        const matrix = sparseMatrixOf(a);
+        const { dense, numbers } = iterativeOf(matrix, b, iterative);
+        return iterativeSolutionOf(await this.#sparseAsync('conjugateGradient', [nativeSparseOf(matrix)], dense, options, numbers));
+    }
+    /**
+     * The solution of `a x = b` by the biconjugate gradient stabilized method (BiCGSTAB), with the diagonal of `a` as
+     * preconditioner (Eigen's `BiCGSTAB`): for a square matrix that need not be symmetric. It stops when the relative
+     * residual reaches the tolerance or after the largest number of iterations; `converged` tells which.
+     * @param a The matrix, square: sparse, or dense (made sparse).
+     * @param b The right side.
+     * @param iterative Its tolerance, its largest number of iterations, its first guess.
+     */
+    biconjugateGradientStabilized(a, b, iterative) {
+        const matrix = sparseMatrixOf(a);
+        const { dense, numbers } = iterativeOf(matrix, b, iterative);
+        return iterativeSolutionOf(sparseRun('biconjugateGradientStabilized', [nativeSparseOf(matrix)], dense, numbers));
+    }
+    /**
+     * `biconjugateGradientStabilized()` in the threads of the addon.
+     * @param a The matrix, square: sparse, or dense (made sparse).
+     * @param b The right side.
+     * @param iterative Its tolerance, its largest number of iterations, its first guess.
+     * @param options Its cancellation, its time limit.
+     */
+    async biconjugateGradientStabilizedAsync(a, b, iterative, options) {
+        const matrix = sparseMatrixOf(a);
+        const { dense, numbers } = iterativeOf(matrix, b, iterative);
+        return iterativeSolutionOf(await this.#sparseAsync('biconjugateGradientStabilized', [nativeSparseOf(matrix)], dense, options, numbers));
+    }
+}