@lakutata/math 0.0.0-stage → 3.1.5

package/native/limits/Gruntz.h

@@ -0,0 +1,24 @@
+//The limits of expressions, by Gruntz's algorithm after SymPy's series/gruntz.py (BSD-3, its notice in
+//THIRD_PARTY_NOTICES.md): a limit at a point is one at inf (z0 + 1/z from above, z0 - 1/z from below, -z for -inf);
+//at inf, the most rapidly varying subexpressions (mrv) of the expression are rewritten as powers of one of them, w,
+//which goes to 0, and the leading term c0 w^e0 of the expression in w gives the limit: 0 for e0 > 0, an infinity of
+//the sign of c0 for e0 < 0, the limit of c0 for e0 = 0. The variable is real, going to inf; w is positive, and log(w)
+//is a symbol in the series in w (SymEngine has no logarithmic series).
+#pragma once
+
+#include <string>
+
+#include <symengine/symbol.h>
+
+#include "../core/Handle.h"
+
+namespace math {
+
+//The limit of an expression for a variable going to a point (inf and -inf too) from above ("+"), from below ("-") or
+//from both sides ("both": the same limit, or MathDomainException); an infinity where it diverges
+Expr limitOf(const Expr &expression, const std::string &variable, const Expr &point, const std::string &direction);
+
+//limitOf() for a symbol (the variables of the algorithms of the addon)
+Expr limitOf(const Expr &expression, const SymEngine::RCP<const SymEngine::Symbol> &variable, const Expr &point, const std::string &direction);
+
+}

package/native/linalg/Decompositions.cpp

@@ -0,0 +1,159 @@
+//The decompositions of matrices on Eigen: LU with partial pivoting, QR and the singular value decomposition (thin),
+//Cholesky's, the eigenvalues and eigenvectors (of a general matrix, of a symmetric one), the real Schur form, and the
+//pseudo-inverse by the singular values. The ones of a symmetric matrix read its lower triangle, as NumPy's.
+#include "LinalgSupport.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+#include <Eigen/Cholesky>
+#include <Eigen/Eigenvalues>
+#include <Eigen/LU>
+#include <Eigen/QR>
+#include <Eigen/SVD>
+
+#include "../async/Pool.h"
+
+namespace math {
+
+namespace {
+
+//The singular values below which a value is 0: max(m, n) eps of the largest (NumPy's pinv and matrix_rank), or a
+//tolerance given
+double thresholdOf(const Eigen::VectorXd &values, Eigen::Index rows, Eigen::Index columns, const std::vector<double> &numbers)
+{
+    if (!numbers.empty()) return numbers[0];
+    return values.size() ? values[0] * static_cast<double>(std::max(rows, columns)) * std::numeric_limits<double>::epsilon() : 0;
+}
+
+}
+
+bool decompositionOf(const std::string &operation, const std::vector<MatrixArgument> &matrices, const std::vector<double> &numbers, std::vector<MatrixResult> &results)
+{
+    if (operation == "lu") {
+        //P A = L U: L of ones on its diagonal, the permutation as the rows of A taken in turn (row i of P A is row p[i]
+        //of A)
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        const Eigen::Index n = static_cast<Eigen::Index>(matrices[0].rows);
+        if (n == 0) {
+            results = {resultOf(Eigen::MatrixXd(0, 0)), resultOf(Eigen::MatrixXd(0, 0)), MatrixResult{0, 1, {}}};
+            return true;
+        }
+        const Eigen::PartialPivLU<Eigen::MatrixXd> lu(copyOf(matrices[0]));
+        checkpoint();
+        Eigen::MatrixXd lower = lu.matrixLU().triangularView<Eigen::StrictlyLower>();
+        lower.diagonal().setOnes();
+        const Eigen::MatrixXd upper = lu.matrixLU().triangularView<Eigen::Upper>();
+        const Eigen::VectorXd indices = Eigen::VectorXd::LinSpaced(n, 0, static_cast<double>(n - 1));
+        const Eigen::VectorXd permutation = lu.permutationP() * indices;
+        results = {resultOf(lower), resultOf(upper), resultOf(permutation)};
+        return true;
+    }
+    if (operation == "qr") {
+        //Thin: Q of m×k orthonormal columns, R of k×n upper triangular, k = min(m, n)
+        requireCount(matrices, 1, operation);
+        const Eigen::MatrixXd a = copyOf(matrices[0]);
+        const Eigen::Index k = std::min(a.rows(), a.cols());
+        if (k == 0) {
+            results = {resultOf(Eigen::MatrixXd::Zero(a.rows(), 0)), resultOf(Eigen::MatrixXd::Zero(0, a.cols()))};
+            return true;
+        }
+        const Eigen::HouseholderQR<Eigen::MatrixXd> qr(a);
+        checkpoint();
+        const Eigen::MatrixXd q = qr.householderQ() * Eigen::MatrixXd::Identity(a.rows(), k);
+        const Eigen::MatrixXd r = qr.matrixQR().topRows(k).triangularView<Eigen::Upper>();
+        results = {resultOf(q), resultOf(r)};
+        return true;
+    }
+    if (operation == "cholesky") {
+        //A = L Lᵀ of a symmetric positive definite matrix, its lower triangle read
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        if (matrices[0].rows == 0) {
+            results = {resultOf(Eigen::MatrixXd(0, 0))};
+            return true;
+        }
+        const Eigen::LLT<Eigen::MatrixXd, Eigen::Lower> llt(copyOf(matrices[0]));
+        if (llt.info() != Eigen::Success) throw MathError(ErrorCode::Domain, "The matrix is not positive definite");
+        results = {resultOf(Eigen::MatrixXd(llt.matrixL()))};
+        return true;
+    }
+    if (operation == "svd") {
+        //Thin: A = U diag(s) Vᵀ, U of m×k, V of n×k, k = min(m, n), s descending
+        requireCount(matrices, 1, operation);
+        const Eigen::MatrixXd a = copyOf(matrices[0]);
+        const Eigen::Index k = std::min(a.rows(), a.cols());
+        if (k == 0) {
+            results = {resultOf(Eigen::MatrixXd::Zero(a.rows(), 0)), MatrixResult{0, 1, {}}, resultOf(Eigen::MatrixXd::Zero(a.cols(), 0))};
+            return true;
+        }
+        const Eigen::BDCSVD<Eigen::MatrixXd, Eigen::ComputeThinU | Eigen::ComputeThinV> svd(a);
+        results = {resultOf(svd.matrixU()), resultOf(svd.singularValues()), resultOf(svd.matrixV())};
+        return true;
+    }
+    if (operation == "eigen") {
+        //Of a general matrix: complex eigenvalues (their real and imaginary parts), eigenvectors of norm 1 as columns
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        const Eigen::Index n = static_cast<Eigen::Index>(matrices[0].rows);
+        if (n == 0) {
+            results = {MatrixResult{0, 1, {}}, MatrixResult{0, 1, {}}, resultOf(Eigen::MatrixXd(0, 0)), resultOf(Eigen::MatrixXd(0, 0))};
+            return true;
+        }
+        const Eigen::EigenSolver<Eigen::MatrixXd> solver(copyOf(matrices[0]));
+        if (solver.info() != Eigen::Success) throw MathError(ErrorCode::NotSupported, "The eigenvalues of the matrix did not converge");
+        const Eigen::VectorXcd values = solver.eigenvalues();
+        const Eigen::MatrixXcd vectors = solver.eigenvectors();
+        results = {resultOf(values.real()), resultOf(values.imag()), resultOf(vectors.real()), resultOf(vectors.imag())};
+        return true;
+    }
+    if (operation == "symmetricEigen") {
+        //Of a symmetric matrix, its lower triangle read (NumPy's eigh): eigenvalues ascending, orthonormal eigenvectors
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        if (matrices[0].rows == 0) {
+            results = {MatrixResult{0, 1, {}}, resultOf(Eigen::MatrixXd(0, 0))};
+            return true;
+        }
+        const Eigen::SelfAdjointEigenSolver<Eigen::MatrixXd> solver(copyOf(matrices[0]));
+        if (solver.info() != Eigen::Success) throw MathError(ErrorCode::NotSupported, "The eigenvalues of the matrix did not converge");
+        results = {resultOf(solver.eigenvalues()), resultOf(solver.eigenvectors())};
+        return true;
+    }
+    if (operation == "schur") {
+        //A = U T Uᵀ: U orthogonal, T quasi upper triangular (blocks of 2×2 on its diagonal for the pairs of complex
+        //eigenvalues)
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        if (matrices[0].rows == 0) {
+            results = {resultOf(Eigen::MatrixXd(0, 0)), resultOf(Eigen::MatrixXd(0, 0))};
+            return true;
+        }
+        const Eigen::RealSchur<Eigen::MatrixXd> schur(copyOf(matrices[0]));
+        if (schur.info() != Eigen::Success) throw MathError(ErrorCode::NotSupported, "The Schur form of the matrix did not converge");
+        results = {resultOf(schur.matrixU()), resultOf(schur.matrixT())};
+        return true;
+    }
+    if (operation == "pseudoInverse") {
+        //V diag(1/s) Uᵀ of the singular values above the threshold
+        requireCount(matrices, 1, operation);
+        const Eigen::MatrixXd a = copyOf(matrices[0]);
+        if (std::min(a.rows(), a.cols()) == 0) {
+            results = {resultOf(Eigen::MatrixXd::Zero(a.cols(), a.rows()))};
+            return true;
+        }
+        const Eigen::BDCSVD<Eigen::MatrixXd, Eigen::ComputeThinU | Eigen::ComputeThinV> svd(a);
+        checkpoint();
+        const Eigen::VectorXd &values = svd.singularValues();
+        const double threshold = thresholdOf(values, a.rows(), a.cols(), numbers);
+        Eigen::VectorXd inverse(values.size());
+        for (Eigen::Index i = 0; i < values.size(); i++) inverse[i] = values[i] > threshold ? 1 / values[i] : 0;
+        results = {resultOf(svd.matrixV() * inverse.asDiagonal() * svd.matrixU().transpose())};
+        return true;
+    }
+    return false;
+}
+
+}

package/native/linalg/Functions.cpp

@@ -0,0 +1,199 @@
+//The functions of matrices on Eigen's decompositions: the exponential (Padé approximants with scaling and squaring,
+//Higham 2005), the principal square root (by the complex Schur form, Björck and Hammarling 1983), and the solutions of
+//the Sylvester and Lyapunov equations (Bartels and Stewart, on the complex Schur forms).
+#include "LinalgSupport.h"
+
+#include <algorithm>
+#include <cmath>
+#include <complex>
+#include <limits>
+
+#include <Eigen/Eigenvalues>
+#include <Eigen/LU>
+
+#include "../async/Pool.h"
+
+namespace math {
+
+namespace {
+
+using Complex = std::complex<double>;
+
+double oneNorm(const Eigen::MatrixXd &a)
+{
+    double norm = 0;
+    for (Eigen::Index j = 0; j < a.cols(); j++) norm = std::max(norm, a.col(j).cwiseAbs().sum());
+    return norm;
+}
+
+//The coefficients of the Padé approximants of degree 3, 5, 7 and 9 of the exponential, and the largest 1-norms each is
+//accurate to the doubles for
+const double PADE_3[] = {120, 60, 12, 1};
+const double PADE_5[] = {30240, 15120, 3360, 420, 30, 1};
+const double PADE_7[] = {17297280, 8648640, 1995840, 277200, 25200, 1512, 56, 1};
+const double PADE_9[] = {17643225600, 8821612800, 2075673600, 302702400, 30270240, 2162160, 110880, 3960, 90, 1};
+const double PADE_13[] = {64764752532480000., 32382376266240000., 7771770303897600., 1187353796428800., 129060195264000., 10559470521600., 670442572800., 33522128640., 1323241920., 40840800., 960960., 16380., 182., 1.};
+const double THETA_LOW[] = {1.495585217958292e-2, 2.539398330063230e-1, 9.504178996162932e-1, 2.097847961257068};
+const double THETA_13 = 5.371920351148152;
+
+//exp(A): the Padé approximant (V - U)⁻¹ (V + U) of the smallest degree of 3, 5, 7 and 9 accurate for the 1-norm of A,
+//otherwise the one of degree 13 of A / 2^s, squared s times (Higham, "The scaling and squaring method for the matrix
+//exponential revisited", 2005). A matrix of an infinite or NaN element gives NaN.
+Eigen::MatrixXd exponentialOf(const Eigen::MatrixXd &a)
+{
+    const Eigen::Index n = a.rows();
+    const double norm = oneNorm(a);
+    if (!std::isfinite(norm)) return Eigen::MatrixXd::Constant(n, n, std::numeric_limits<double>::quiet_NaN());
+    const Eigen::MatrixXd identity = Eigen::MatrixXd::Identity(n, n);
+    Eigen::MatrixXd u, v;
+    int squarings = 0;
+    const double *const low[] = {PADE_3, PADE_5, PADE_7, PADE_9};
+    const int degrees[] = {3, 5, 7, 9};
+    int degree = 13;
+    for (int index = 0; index < 4; index++) {
+        if (norm > THETA_LOW[index]) continue;
+        degree = degrees[index];
+        const double *b = low[index];
+        const Eigen::MatrixXd square = a * a;
+        Eigen::MatrixXd power = identity, odd = Eigen::MatrixXd::Zero(n, n), even = Eigen::MatrixXd::Zero(n, n);
+        for (int k = 0; 2 * k < degree; k++) {
+            if (k) power = power * square;
+            odd += b[2 * k + 1] * power;
+            even += b[2 * k] * power;
+        }
+        u = a * odd;
+        v = even;
+        break;
+    }
+    if (degree == 13) {
+        squarings = std::max(0, static_cast<int>(std::ceil(std::log2(norm / THETA_13))));
+        const Eigen::MatrixXd scaled = a * std::ldexp(1.0, -squarings);
+        const double *b = PADE_13;
+        const Eigen::MatrixXd a2 = scaled * scaled, a4 = a2 * a2, a6 = a4 * a2;
+        u = scaled * (a6 * (b[13] * a6 + b[11] * a4 + b[9] * a2) + b[7] * a6 + b[5] * a4 + b[3] * a2 + b[1] * identity);
+        v = a6 * (b[12] * a6 + b[10] * a4 + b[8] * a2) + b[6] * a6 + b[4] * a4 + b[2] * a2 + b[0] * identity;
+    }
+    checkpoint();
+    Eigen::MatrixXd result = (v - u).partialPivLu().solve(v + u);
+    for (int i = 0; i < squarings; i++) {
+        checkpoint();
+        result = result * result;
+    }
+    return result;
+}
+
+[[noreturn]] void noSquareRoot()
+{
+    throw MathError(ErrorCode::Domain, "The matrix has no principal square root");
+}
+
+//The principal square root: A = U T U* (complex Schur), R upper triangular of R² = T column by column (Björck and
+//Hammarling), X = U R U*. Where A has no negative eigenvalue, its imaginary part is of the roundings and the root is
+//its real part; otherwise the root is not real.
+Eigen::MatrixXd squareRootOf(const Eigen::MatrixXd &a)
+{
+    const Eigen::Index n = a.rows();
+    const Eigen::ComplexSchur<Eigen::MatrixXd> schur(a);
+    if (schur.info() != Eigen::Success) throw MathError(ErrorCode::NotSupported, "The Schur form of the matrix did not converge");
+    const Eigen::MatrixXcd &t = schur.matrixT();
+    Eigen::MatrixXcd r = Eigen::MatrixXcd::Zero(n, n);
+    for (Eigen::Index j = 0; j < n; j++) {
+        r(j, j) = std::sqrt(t(j, j));
+        for (Eigen::Index i = j - 1; i >= 0; i--) {
+            Complex sum = t(i, j);
+            for (Eigen::Index k = i + 1; k < j; k++) sum -= r(i, k) * r(k, j);
+            const Complex denominator = r(i, i) + r(j, j);
+            if (denominator == 0.0) {
+                //Two eigenvalues of 0: a root only where its element is 0 too
+                if (sum != 0.0) noSquareRoot();
+                continue;
+            }
+            r(i, j) = sum / denominator;
+        }
+        checkpoint();
+    }
+    const Eigen::MatrixXcd root = schur.matrixU() * r * schur.matrixU().adjoint();
+    if (!root.allFinite()) noSquareRoot();
+    if (root.imag().norm() > std::sqrt(std::numeric_limits<double>::epsilon()) * root.norm()) {
+        throw MathError(ErrorCode::Domain, "The principal square root of the matrix is not real: it has a negative eigenvalue");
+    }
+    return root.real();
+}
+
+//X of A X + X B = C: A = U S U*, B = V T V* (complex Schur), S Y + Y T = U* C V solved column by column as triangular
+//systems, X = U Y V* (Bartels and Stewart). The solution is unique when no eigenvalue of A is the opposite of one of B:
+//a system meeting a pivot of exactly 0 has none, as solve(), and throws the reason given
+Eigen::MatrixXd sylvesterOf(const Eigen::MatrixXd &a, const Eigen::MatrixXd &b, const Eigen::MatrixXd &c, const char *reason)
+{
+    const auto noUniqueSolution = [reason]() {
+        throw MathError(ErrorCode::Domain, std::string("The equation has no unique solution: ") + reason);
+    };
+    const Eigen::Index m = a.rows(), n = b.rows();
+    if (m == 0 || n == 0) return Eigen::MatrixXd::Zero(m, n);
+    const Eigen::ComplexSchur<Eigen::MatrixXd> left(a), right(b);
+    if (left.info() != Eigen::Success || right.info() != Eigen::Success) throw MathError(ErrorCode::NotSupported, "The Schur form of the matrix did not converge");
+    const Eigen::MatrixXcd &s = left.matrixT(), &t = right.matrixT();
+    const Eigen::MatrixXcd f = left.matrixU().adjoint() * c.cast<Complex>() * right.matrixU();
+    Eigen::MatrixXcd y(m, n);
+    for (Eigen::Index k = 0; k < n; k++) {
+        Eigen::VectorXcd side = f.col(k);
+        for (Eigen::Index j = 0; j < k; j++) side -= t(j, k) * y.col(j);
+        Eigen::MatrixXcd system = s;
+        system.diagonal().array() += t(k, k);
+        for (Eigen::Index i = 0; i < m; i++) {
+            if (system(i, i) == 0.0) noUniqueSolution();
+        }
+        y.col(k) = system.triangularView<Eigen::Upper>().solve(side);
+        checkpoint();
+    }
+    const Eigen::MatrixXd solution = (left.matrixU() * y * right.matrixU().adjoint()).real();
+    if (!solution.allFinite() && c.allFinite() && a.allFinite() && b.allFinite()) noUniqueSolution();
+    return solution;
+}
+
+}
+
+bool matrixFunctionOf(const std::string &operation, const std::vector<MatrixArgument> &matrices, std::vector<MatrixResult> &results)
+{
+    if (operation == "exponential") {
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        results = {resultOf(exponentialOf(copyOf(matrices[0])))};
+        return true;
+    }
+    if (operation == "squareRoot") {
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        if (matrices[0].rows == 0) {
+            results = {resultOf(Eigen::MatrixXd(0, 0))};
+            return true;
+        }
+        results = {resultOf(squareRootOf(copyOf(matrices[0])))};
+        return true;
+    }
+    if (operation == "sylvester") {
+        //A X + X B = C: A of m×m, B of n×n, C of m×n
+        requireCount(matrices, 3, operation);
+        requireSquare(matrices[0], "A");
+        requireSquare(matrices[1], "B");
+        requireRows(matrices[2], matrices[0].rows, "C");
+        if (matrices[2].columns != matrices[1].rows) {
+            throw MathError(ErrorCode::Argument, "C is " + std::to_string(matrices[2].rows) + "×" + std::to_string(matrices[2].columns) + ", not " + std::to_string(matrices[0].rows) + "×" + std::to_string(matrices[1].rows));
+        }
+        results = {resultOf(sylvesterOf(copyOf(matrices[0]), copyOf(matrices[1]), copyOf(matrices[2]), "an eigenvalue of A is the opposite of one of B"))};
+        return true;
+    }
+    if (operation == "lyapunov") {
+        //A P + P Aᵀ + Q = 0 (mathjs's lyap, MATLAB's): the Sylvester equation A P + P Aᵀ = -Q
+        requireCount(matrices, 2, operation);
+        requireSquare(matrices[0], "A");
+        requireSquare(matrices[1], "Q");
+        requireRows(matrices[1], matrices[0].rows, "Q");
+        const Eigen::MatrixXd a = copyOf(matrices[0]);
+        results = {resultOf(sylvesterOf(a, a.transpose(), -copyOf(matrices[1]), "A has eigenvalues λ and μ, possibly the same, with λ + μ = 0"))};
+        return true;
+    }
+    return false;
+}
+
+}

package/native/linalg/Linalg.cpp

@@ -0,0 +1,123 @@
+//The dense linear algebra on Eigen: products, linear systems, inverses, determinants, singular values. The products map
+//the row-major elements in place; the decompositions work on a column-major copy (nothing next to their cost, and one
+//instantiation of each).
+#include "Linalg.h"
+#include "LinalgSupport.h"
+
+#include <cmath>
+#include <limits>
+
+#include <Eigen/Dense>
+
+#include "../async/Pool.h"
+#include "../core/Errors.h"
+
+namespace math {
+
+namespace {
+
+using RowMajor = RowMajorMatrix;
+
+[[noreturn]] void singular()
+{
+    throw MathError(ErrorCode::Domain, "The matrix is singular");
+}
+
+//The LU decomposition of a square matrix with partial pivoting; singular where it meets a pivot of exactly 0 (as
+//NumPy: a matrix close to singular gives its large values)
+Eigen::PartialPivLU<Eigen::MatrixXd> luOf(const MatrixArgument &matrix)
+{
+    Eigen::PartialPivLU<Eigen::MatrixXd> lu(copyOf(matrix));
+    return lu;
+}
+
+bool zeroPivot(const Eigen::PartialPivLU<Eigen::MatrixXd> &lu)
+{
+    const auto diagonal = lu.matrixLU().diagonal();
+    for (Eigen::Index i = 0; i < diagonal.size(); i++) {
+        if (diagonal[i] == 0) return true;
+    }
+    return false;
+}
+
+}
+
+std::vector<MatrixResult> linalgOf(const std::string &operation, const std::vector<MatrixArgument> &matrices, const std::vector<double> &numbers, const std::string &option)
+{
+    std::vector<MatrixResult> decomposed;
+    if (decompositionOf(operation, matrices, numbers, decomposed)) return decomposed;
+    if (matrixFunctionOf(operation, matrices, decomposed)) return decomposed;
+    if (operation == "multiply") {
+        requireCount(matrices, 2, operation);
+        const MatrixArgument &a = matrices[0], &b = matrices[1];
+        if (a.columns != b.rows) {
+            throw MathError(ErrorCode::Argument, "The matrices cannot be multiplied: " + std::to_string(a.rows) + "×" + std::to_string(a.columns) + " by " + std::to_string(b.rows) + "×" + std::to_string(b.columns));
+        }
+        RowMajor product = mapOf(a) * mapOf(b);
+        return {resultOf(product)};
+    }
+    if (operation == "solve") {
+        requireCount(matrices, 2, operation);
+        requireSquare(matrices[0], "The matrix of the system");
+        requireRows(matrices[1], matrices[0].rows, "The right-hand side");
+        if (matrices[0].rows == 0) return {MatrixResult{0, matrices[1].columns, {}}};
+        const auto lu = luOf(matrices[0]);
+        if (zeroPivot(lu)) singular();
+        checkpoint();
+        return {resultOf(lu.solve(copyOf(matrices[1])))};
+    }
+    if (operation == "solveTriangular") {
+        requireCount(matrices, 2, operation);
+        requireSquare(matrices[0], "The triangular matrix");
+        requireRows(matrices[1], matrices[0].rows, "The right-hand side");
+        if (option != "lower" && option != "upper") throw MathError(ErrorCode::Argument, "A triangular matrix is lower or upper");
+        if (matrices[0].rows == 0) return {MatrixResult{0, matrices[1].columns, {}}};
+        const Eigen::MatrixXd a = copyOf(matrices[0]);
+        for (Eigen::Index i = 0; i < a.rows(); i++) {
+            if (a(i, i) == 0) singular();
+        }
+        const Eigen::MatrixXd b = copyOf(matrices[1]);
+        if (option == "lower") return {resultOf(a.triangularView<Eigen::Lower>().solve(b))};
+        return {resultOf(a.triangularView<Eigen::Upper>().solve(b))};
+    }
+    if (operation == "leastSquares") {
+        //The minimum-norm least-squares solution, by the singular values above max(m, n) eps of the largest (NumPy's
+        //lstsq)
+        requireCount(matrices, 2, operation);
+        requireRows(matrices[1], matrices[0].rows, "The right-hand side");
+        const Eigen::MatrixXd a = copyOf(matrices[0]);
+        if (a.size() == 0) return {resultOf(Eigen::MatrixXd::Zero(a.cols(), static_cast<Eigen::Index>(matrices[1].columns)))};
+        Eigen::BDCSVD<Eigen::MatrixXd, Eigen::ComputeThinU | Eigen::ComputeThinV> svd(a);
+        svd.setThreshold(std::numeric_limits<double>::epsilon() * static_cast<double>(std::max(a.rows(), a.cols())));
+        checkpoint();
+        return {resultOf(svd.solve(copyOf(matrices[1])))};
+    }
+    if (operation == "inverse") {
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        if (matrices[0].rows == 0) return {MatrixResult{0, 0, {}}};
+        const auto lu = luOf(matrices[0]);
+        if (zeroPivot(lu)) singular();
+        checkpoint();
+        return {resultOf(lu.inverse())};
+    }
+    if (operation == "determinant") {
+        requireCount(matrices, 1, operation);
+        requireSquare(matrices[0], "The matrix");
+        if (matrices[0].rows == 0) return {numberOf(1)};
+        //No negative 0 (the sign of the permutation times a pivot of 0)
+        const double determinant = luOf(matrices[0]).determinant();
+        return {numberOf(determinant == 0 ? 0.0 : determinant)};
+    }
+    if (operation == "singularValues") {
+        //Descending
+        requireCount(matrices, 1, operation);
+        const Eigen::MatrixXd a = copyOf(matrices[0]);
+        if (a.size() == 0) return {MatrixResult{0, 1, {}}};
+        Eigen::BDCSVD<Eigen::MatrixXd> svd(a);
+        return {resultOf(svd.singularValues())};
+    }
+    throw MathError(ErrorCode::Argument, "Unknown operation of the linear algebra: " + operation);
+}
+
+}

package/native/linalg/Linalg.h

@@ -0,0 +1,67 @@
+//The numeric linear algebra (math.linalg, Matrix, SparseMatrix): dense and sparse matrices of doubles on Eigen
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace math {
+
+//A dense matrix of doubles, row-major: the elements of a Float64Array, borrowed by a synchronous operation, or their
+//copy, owned by an asynchronous one
+struct MatrixArgument {
+    size_t rows = 0;
+    size_t columns = 0;
+    const double *values = nullptr;
+    std::shared_ptr<const std::vector<double>> owned;
+};
+
+//A matrix of a result, row-major (a vector is a column, a number a matrix of one element)
+struct MatrixResult {
+    size_t rows = 0;
+    size_t columns = 0;
+    std::vector<double> values;
+};
+
+//An operation of the linear algebra on matrices, with its options (numbers, a text): its results, in the order of the
+//operation. The dimensions are checked before Eigen sees them (its assertions are not errors); a singular matrix where
+//an inverse is needed throws MathError (Domain), a matrix of the wrong dimensions MathError (Argument)
+std::vector<MatrixResult> linalgOf(const std::string &operation, const std::vector<MatrixArgument> &matrices, const std::vector<double> &numbers, const std::string &option);
+
+//A sparse matrix in compressed rows: the entries of row i are pointers[i] to pointers[i + 1] - 1, of the columns
+//indices[k] and the values values[k]; borrowed by a synchronous operation or copied for an asynchronous one, as a
+//matrix. Nothing about them is trusted before sparseOf() checks them.
+struct SparseArgument {
+    size_t rows = 0;
+    size_t columns = 0;
+    size_t entries = 0;
+    const int32_t *pointers = nullptr;
+    const int32_t *indices = nullptr;
+    const double *values = nullptr;
+    std::shared_ptr<const std::vector<int32_t>> ownedPointers;
+    std::shared_ptr<const std::vector<int32_t>> ownedIndices;
+    std::shared_ptr<const std::vector<double>> ownedValues;
+};
+
+//A sparse matrix of a result, in compressed rows of increasing columns
+struct SparseResult {
+    size_t rows = 0;
+    size_t columns = 0;
+    std::vector<int32_t> pointers;
+    std::vector<int32_t> indices;
+    std::vector<double> values;
+};
+
+//The results of an operation on sparse matrices: its dense matrices and its sparse ones, each in its order
+struct SparseResults {
+    std::vector<MatrixResult> dense;
+    std::vector<SparseResult> sparse;
+};
+
+//An operation on sparse matrices (and dense ones, numbers): the structure of each sparse matrix is checked first (its
+//pointers, its columns increasing in each row) and throws MathError (Argument) where it is not one
+SparseResults sparseOf(const std::string &operation, const std::vector<SparseArgument> &sparse, const std::vector<MatrixArgument> &dense, const std::vector<double> &numbers);
+
+}

package/native/linalg/LinalgSupport.h

@@ -0,0 +1,69 @@
+//The helpers of the linear algebra (Linalg.cpp, Decompositions.cpp, Functions.cpp): the maps and copies of the matrices
+//given, the results, the checks of their dimensions
+#pragma once
+
+#include <string>
+#include <vector>
+
+#include <Eigen/Core>
+
+#include "Linalg.h"
+#include "../core/Errors.h"
+
+namespace math {
+
+using RowMajorMatrix = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::RowMajor>;
+using MatrixMap = Eigen::Map<const RowMajorMatrix>;
+
+inline MatrixMap mapOf(const MatrixArgument &matrix)
+{
+    return MatrixMap(matrix.values, static_cast<Eigen::Index>(matrix.rows), static_cast<Eigen::Index>(matrix.columns));
+}
+
+//A column-major copy, for the decompositions (nothing next to their cost, and one instantiation of each)
+inline Eigen::MatrixXd copyOf(const MatrixArgument &matrix)
+{
+    return mapOf(matrix);
+}
+
+template <typename Derived>
+MatrixResult resultOf(const Eigen::MatrixBase<Derived> &matrix)
+{
+    MatrixResult result;
+    result.rows = static_cast<size_t>(matrix.rows());
+    result.columns = static_cast<size_t>(matrix.cols());
+    result.values.resize(result.rows * result.columns);
+    Eigen::Map<RowMajorMatrix>(result.values.data(), matrix.rows(), matrix.cols()) = matrix;
+    return result;
+}
+
+inline MatrixResult numberOf(double value)
+{
+    return {1, 1, {value}};
+}
+
+inline void requireSquare(const MatrixArgument &matrix, const char *what)
+{
+    if (matrix.rows != matrix.columns) {
+        throw MathError(ErrorCode::Argument, std::string(what) + " is not square (" + std::to_string(matrix.rows) + "×" + std::to_string(matrix.columns) + ")");
+    }
+}
+
+inline void requireRows(const MatrixArgument &matrix, size_t rows, const char *what)
+{
+    if (matrix.rows != rows) throw MathError(ErrorCode::Argument, std::string(what) + " has " + std::to_string(matrix.rows) + (matrix.rows == 1 ? " row" : " rows") + ", not " + std::to_string(rows));
+}
+
+inline void requireCount(const std::vector<MatrixArgument> &matrices, size_t count, const std::string &operation)
+{
+    if (matrices.size() != count) throw MathError(ErrorCode::Argument, "The operation " + operation + " takes " + std::to_string(count) + " matrices");
+}
+
+//The decompositions (Decompositions.cpp): the results of an operation that is one of them, false otherwise
+bool decompositionOf(const std::string &operation, const std::vector<MatrixArgument> &matrices, const std::vector<double> &numbers, std::vector<MatrixResult> &results);
+
+//The functions of matrices and the Sylvester and Lyapunov equations (Functions.cpp): the results of an operation that
+//is one of them, false otherwise
+bool matrixFunctionOf(const std::string &operation, const std::vector<MatrixArgument> &matrices, std::vector<MatrixResult> &results);
+
+}