@lakutata/math 0.0.0-stage → 3.1.3

package/native/stats/Statistics.cpp

@@ -0,0 +1,255 @@
+//The statistics of vectors of doubles: compensated sums (Neumaier's), variances and covariances by the corrected
+//two-pass algorithm, medians by selection, quantiles by the linear interpolation of NumPy (its formula, for the same
+//roundings), modes by sorting.
+#include "Statistics.h"
+
+#include <algorithm>
+#include <cmath>
+#include <limits>
+
+#include "../core/Errors.h"
+
+namespace math {
+
+namespace {
+
+constexpr double NOT_A_NUMBER = std::numeric_limits<double>::quiet_NaN();
+
+//A sum compensated for its roundings (Neumaier's); the plain sum where it is not finite (an infinity among the terms,
+//or an overflow), which the compensation would turn into NaN
+struct Accumulator {
+    double sum = 0;
+    double compensation = 0;
+    double plain = 0;
+
+    void add(double value)
+    {
+        const double next = sum + value;
+        compensation += std::abs(sum) >= std::abs(value) ? (sum - next) + value : (value - next) + sum;
+        sum = next;
+        plain += value;
+    }
+
+    double value() const
+    {
+        return std::isfinite(plain) ? sum + compensation : plain;
+    }
+};
+
+double sumOf(const double *values, size_t size)
+{
+    Accumulator accumulator;
+    for (size_t i = 0; i < size; i++) accumulator.add(values[i]);
+    return accumulator.value();
+}
+
+bool hasNaN(const double *values, size_t size)
+{
+    for (size_t i = 0; i < size; i++) {
+        if (std::isnan(values[i])) return true;
+    }
+    return false;
+}
+
+void requireValues(const VectorArgument &vector)
+{
+    if (vector.size == 0) throw MathError(ErrorCode::Argument, "The values are empty");
+}
+
+void requireSameSize(const VectorArgument &x, const VectorArgument &y)
+{
+    if (x.size != y.size) throw MathError(ErrorCode::Argument, "The two vectors differ in length: " + std::to_string(x.size) + " and " + std::to_string(y.size));
+}
+
+//The divisor of a sum of squared deviations: n (uncorrected, 0), n - 1 (unbiased, 1), n + 1 (biased, 2)
+double divisorOf(size_t size, const std::vector<double> &numbers)
+{
+    const double normalization = numbers.empty() ? 0 : numbers[0];
+    if (normalization == 0) return static_cast<double>(size);
+    if (normalization == 1) return static_cast<double>(size) - 1;
+    if (normalization == 2) return static_cast<double>(size) + 1;
+    throw MathError(ErrorCode::Argument, "The normalization is 'uncorrected', 'unbiased' or 'biased'");
+}
+
+double meanOf(const double *values, size_t size)
+{
+    return sumOf(values, size) / static_cast<double>(size);
+}
+
+//The sums of the products of the deviations from the means, corrected by the sums of the deviations (which are 0 but
+//for the roundings of the means)
+double deviationsOf(const double *x, const double *y, size_t size)
+{
+    const double mx = meanOf(x, size), my = meanOf(y, size);
+    Accumulator products, dx, dy;
+    for (size_t i = 0; i < size; i++) {
+        products.add((x[i] - mx) * (y[i] - my));
+        dx.add(x[i] - mx);
+        dy.add(y[i] - my);
+    }
+    return products.value() - dx.value() * dy.value() / static_cast<double>(size);
+}
+
+double varianceOf(const double *values, size_t size, const std::vector<double> &numbers)
+{
+    return deviationsOf(values, values, size) / divisorOf(size, numbers);
+}
+
+//The middle of two values, as their mean, without overflowing
+double middleOf(double a, double b)
+{
+    const double sum = a + b;
+    return std::isfinite(sum) || !std::isfinite(a) || !std::isfinite(b) ? sum / 2 : a / 2 + b / 2;
+}
+
+double medianOf(std::vector<double> values)
+{
+    const size_t k = values.size() / 2;
+    std::nth_element(values.begin(), values.begin() + static_cast<std::ptrdiff_t>(k), values.end());
+    if (values.size() % 2 == 1) return values[k];
+    const double below = *std::max_element(values.begin(), values.begin() + static_cast<std::ptrdiff_t>(k));
+    return middleOf(below, values[k]);
+}
+
+//The quantile of p of sorted values: NumPy's linear interpolation between the values of the indices around (n - 1) p,
+//by its formula (from the nearer one)
+double quantileOf(const std::vector<double> &sorted, double p)
+{
+    const double index = (static_cast<double>(sorted.size()) - 1) * p;
+    const double below = std::floor(index);
+    const size_t lower = static_cast<size_t>(below), upper = std::min(lower + 1, sorted.size() - 1);
+    const double t = index - below, a = sorted[lower], b = sorted[upper];
+    const double difference = b - a;
+    return t >= 0.5 ? b - difference * (1 - t) : a + difference * t;
+}
+
+std::vector<double> copyOf(const VectorArgument &vector)
+{
+    return std::vector<double>(vector.values, vector.values + vector.size);
+}
+
+void requireCount(const std::vector<VectorArgument> &vectors, size_t count, const std::string &operation)
+{
+    if (vectors.size() != count) throw MathError(ErrorCode::Argument, "The statistic " + operation + " takes " + std::to_string(count) + " vectors");
+}
+
+}
+
+std::vector<std::vector<double>> statisticsOf(const std::string &operation, const std::vector<VectorArgument> &vectors, const std::vector<double> &numbers)
+{
+    const bool pair = operation == "cov" || operation == "corr" || operation == "kldivergence";
+    requireCount(vectors, operation == "quantile" || pair ? 2 : 1, operation);
+    const VectorArgument &x = vectors[0];
+    const double *values = x.values;
+    const size_t n = x.size;
+    if (operation == "sum") return {{sumOf(values, n)}};
+    if (operation == "prod") {
+        double product = 1;
+        for (size_t i = 0; i < n; i++) product *= values[i];
+        return {{product}};
+    }
+    if (operation == "cumsum") {
+        std::vector<double> sums(n);
+        Accumulator accumulator;
+        for (size_t i = 0; i < n; i++) {
+            accumulator.add(values[i]);
+            sums[i] = accumulator.value();
+        }
+        return {sums};
+    }
+    if (operation == "diff") {
+        std::vector<double> differences(n > 0 ? n - 1 : 0);
+        for (size_t i = 0; i + 1 < n; i++) differences[i] = values[i + 1] - values[i];
+        return {differences};
+    }
+    if (operation == "zscore") {
+        if (n == 0) return {std::vector<double>()};
+        const double mean = meanOf(values, n), deviation = std::sqrt(varianceOf(values, n, numbers));
+        std::vector<double> scores(n);
+        for (size_t i = 0; i < n; i++) scores[i] = (values[i] - mean) / deviation;
+        return {scores};
+    }
+    if (operation == "kldivergence") {
+        //Of two distributions, each normalized to a sum of 1: Σ p log(p / q), a term of p = 0 being 0 and one of q = 0
+        //(p > 0) infinite (SciPy's entropy)
+        const VectorArgument &y = vectors[1];
+        requireSameSize(x, y);
+        requireValues(x);
+        for (size_t i = 0; i < n; i++) {
+            if (x.values[i] < 0 || y.values[i] < 0) throw MathError(ErrorCode::Argument, "A probability of a distribution is negative");
+        }
+        const double total = sumOf(x.values, n), otherTotal = sumOf(y.values, n);
+        if (std::isnan(total) || std::isnan(otherTotal)) return {{NOT_A_NUMBER}};
+        if (!(total > 0) || !(otherTotal > 0)) throw MathError(ErrorCode::Argument, "The probabilities of a distribution add up to 0");
+        Accumulator divergence;
+        for (size_t i = 0; i < n; i++) {
+            const double p = x.values[i] / total, q = y.values[i] / otherTotal;
+            if (std::isnan(p) || std::isnan(q)) return {{NOT_A_NUMBER}};
+            if (p == 0) continue;
+            divergence.add(q == 0 ? std::numeric_limits<double>::infinity() : p * std::log(p / q));
+        }
+        return {{divergence.value()}};
+    }
+    requireValues(x);
+    if (operation == "mean") return {{meanOf(values, n)}};
+    if (operation == "min" || operation == "max") {
+        if (hasNaN(values, n)) return {{NOT_A_NUMBER}};
+        return {{operation == "min" ? *std::min_element(values, values + n) : *std::max_element(values, values + n)}};
+    }
+    if (operation == "variance") return {{varianceOf(values, n, numbers)}};
+    if (operation == "std") return {{std::sqrt(varianceOf(values, n, numbers))}};
+    if (operation == "cov" || operation == "corr") {
+        const VectorArgument &y = vectors[1];
+        requireSameSize(x, y);
+        if (operation == "cov") return {{deviationsOf(x.values, y.values, n) / divisorOf(n, numbers)}};
+        //Pearson's: the normalizations cancel; within [-1, 1] despite the roundings
+        const double xy = deviationsOf(x.values, y.values, n), xx = deviationsOf(x.values, x.values, n), yy = deviationsOf(y.values, y.values, n);
+        const double r = xy / std::sqrt(xx * yy);
+        return {{std::isnan(r) ? r : std::max(-1.0, std::min(1.0, r))}};
+    }
+    //The statistics of the order of the values: NaN where one of them is NaN (it has no place in it)
+    if (hasNaN(values, n)) {
+        if (operation == "quantile") return {std::vector<double>(vectors[1].size, NOT_A_NUMBER)};
+        return {{NOT_A_NUMBER}};
+    }
+    if (operation == "median") return {{medianOf(copyOf(x))}};
+    if (operation == "mad") {
+        //The median absolute deviation, from the median
+        const double median = medianOf(copyOf(x));
+        std::vector<double> deviations(n);
+        for (size_t i = 0; i < n; i++) deviations[i] = std::abs(values[i] - median);
+        return {{medianOf(std::move(deviations))}};
+    }
+    if (operation == "quantile") {
+        const VectorArgument &probabilities = vectors[1];
+        for (size_t i = 0; i < probabilities.size; i++) {
+            if (!(probabilities.values[i] >= 0 && probabilities.values[i] <= 1)) throw MathError(ErrorCode::Argument, "A probability of a quantile is from 0 to 1");
+        }
+        std::vector<double> sorted = copyOf(x);
+        std::sort(sorted.begin(), sorted.end());
+        std::vector<double> quantiles(probabilities.size);
+        for (size_t i = 0; i < probabilities.size; i++) quantiles[i] = quantileOf(sorted, probabilities.values[i]);
+        return {quantiles};
+    }
+    if (operation == "mode") {
+        //The values of the most occurrences, ascending
+        std::vector<double> sorted = copyOf(x);
+        std::sort(sorted.begin(), sorted.end());
+        std::vector<double> modes;
+        size_t most = 0;
+        for (size_t start = 0; start < n;) {
+            size_t end = start;
+            while (end < n && sorted[end] == sorted[start]) end++;
+            if (end - start > most) {
+                most = end - start;
+                modes.clear();
+            }
+            if (end - start == most) modes.push_back(sorted[start]);
+            start = end;
+        }
+        return {modes};
+    }
+    throw MathError(ErrorCode::Argument, "Unknown statistic: " + operation);
+}
+
+}

package/native/stats/Statistics.h

@@ -0,0 +1,25 @@
+//The statistics of vectors of doubles (math.stats): sums, means, medians, modes, variances, quantiles, covariances,
+//correlations, z-scores, divergences
+#pragma once
+
+#include <cstddef>
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace math {
+
+//A vector of doubles: the elements of a Float64Array, borrowed by a synchronous operation or copied for an
+//asynchronous one
+struct VectorArgument {
+    size_t size = 0;
+    const double *values = nullptr;
+    std::shared_ptr<const std::vector<double>> owned;
+};
+
+//An operation of the statistics on vectors, with its options (numbers): its results, each a vector (a number is a
+//vector of one element). Values that are empty where the statistic has none, vectors of different lengths and options
+//outside their range throw MathError (Argument); a NaN among the values gives NaN.
+std::vector<std::vector<double>> statisticsOf(const std::string &operation, const std::vector<VectorArgument> &vectors, const std::vector<double> &numbers);
+
+}

package/package.json

@@ -1,6 +1,87 @@
 {
   "name": "@lakutata/math",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "3.1.3",
+  "description": "Mathematics for Node.js: symbolic computation (equations, derivatives, integrals, limits, Laplace transforms, factoring, simplification) and numerical computation (matrices, statistics, probability, numeric solutions, units, decimals of any precision) in a native addon built on SymEngine, Boost, Eigen and mpdecimal, used as functions.",
+  "keywords": [
+    "lakutata",
+    "math",
+    "symbolic",
+    "cas",
+    "algebra",
+    "calculus",
+    "integration",
+    "limits",
+    "laplace-transform",
+    "equation-solver",
+    "linear-algebra",
+    "statistics",
+    "units",
+    "decimal",
+    "symengine",
+    "native",
+    "typescript"
+  ],
+  "homepage": "https://lakutata.com/packages/math",
+  "bugs": {
+    "url": "https://github.com/lakutata/lakutata/issues",
+    "email": "admin@lakutata.com"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/lakutata/lakutata.git",
+    "directory": "packages/math"
+  },
+  "author": "alex.ma",
+  "license": "MIT",
+  "type": "module",
+  "main": "./dist/cjs/exports/Math.js",
+  "types": "./dist/cjs/exports/Math.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/types/exports/Math.d.ts",
+        "default": "./dist/esm/exports/Math.js"
+      },
+      "require": {
+        "types": "./dist/cjs/exports/Math.d.ts",
+        "default": "./dist/cjs/exports/Math.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "gypfile": true,
+  "scripts": {
+    "install": "node-gyp rebuild -j max",
+    "build:native": "node-gyp rebuild -j max",
+    "clean": "node -e \"require('node:fs').rmSync('dist', {recursive: true, force: true})\"",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:cjs-pkg": "node ../../scripts/package-build/cjs-package.mjs",
+    "build:addon": "node scripts/addon.mjs",
+    "build:js": "npm run build:cjs && npm run build:esm && npm run build:cjs-pkg && npm run build:addon",
+    "rebuild": "npm run clean && npm run build:js",
+    "compile": "npm run rebuild",
+    "test:unit": "npm run compile && node --test --test-timeout=120000 \"dist/esm/tests/**/*.spec.js\"",
+    "test:fuzz": "npm run compile && node dist/esm/tests/support/FuzzRunner.js --iterations 20000 --fail",
+    "test:bun": "sh test-env/bun.sh",
+    "test:electron": "electron test-env/electron/main.mjs"
+  },
+  "engines": {
+    "node": "^22.13.0 || >=24.11.0"
+  },
+  "files": [
+    "dist",
+    "!dist/*/tests",
+    "binding.gyp",
+    "native",
+    "vendor",
+    "!vendor/UPSTREAM.json",
+    "scripts/sources.mjs",
+    "*.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "dependencies": {
+    "node-addon-api": "^8.9.2"
+  }
+}

package/scripts/sources.mjs

@@ -0,0 +1,35 @@
+// The sources of a target of binding.gyp, one by line, from the package's directory: gyp reads them by
+// <!@(node scripts/sources.mjs <target>) when the addon is built, so the list follows the vendored libraries
+// (scripts/sync.mjs) without being written by hand. Run when the package is installed: Node.js only.
+//
+// Run: node scripts/sources.mjs <symengine|mpdecimal|math>
+
+import {readdirSync} from 'node:fs'
+import path from 'node:path'
+import {fileURLToPath} from 'node:url'
+
+const PACKAGE = fileURLToPath(new URL('..', import.meta.url))
+
+/**
+ * The targets: the directory of their sources, their extensions, the files left out (included by another source)
+ */
+const TARGETS = {
+    symengine: {directory: 'vendor/symengine/symengine', extensions: /\.(cpp|cc)$/, exclude: new Set(['vendor/symengine/symengine/as_real_imag.cpp'])},
+    mpdecimal: {directory: 'vendor/mpdecimal/libmpdec', extensions: /\.c$/, exclude: new Set()},
+    math: {directory: 'native', extensions: /\.cpp$/, exclude: new Set()}
+}
+
+/**
+ * The files of a directory, deep, from the package's directory ("/" separated)
+ * @param directory
+ */
+function filesOf(directory) {
+    return readdirSync(path.join(PACKAGE, directory), {withFileTypes: true}).flatMap((entry) => {
+        const relative = `${directory}/${entry.name}`
+        return entry.isDirectory() ? filesOf(relative) : [relative]
+    })
+}
+
+const target = TARGETS[process.argv[2]]
+if (!target) throw new Error(`Run: node scripts/sources.mjs <${Object.keys(TARGETS).join('|')}>`)
+console.log(filesOf(target.directory).filter((file) => target.extensions.test(file) && !target.exclude.has(file)).sort().join('\n'))

package/vendor/PATCHES.md

@@ -0,0 +1,169 @@
+# Changes to the vendored libraries
+
+The libraries in this directory are copied from their releases (`vendor/UPSTREAM.json` records each version, archive and
+checksum) by `scripts/sync.mjs`, which keeps the changes below through a three-way merge when a library is upgraded.
+Boost.Multiprecision, Boost.Config and mpdecimal are unchanged. The configuration headers the builds of CMake
+would generate are in `native/config`.
+
+## SymEngine
+
+### Built on standalone Boost.Multiprecision
+
+SymEngine's `boostmp` integers come from Boost.Multiprecision, which can be used without the rest of Boost
+(`BOOST_MP_STANDALONE`), but SymEngine also includes Boost.Random and Boost.MPL.
+
+- `symengine/mp_class.h`: the random integers use `std::mt19937` and the `uniform_int_distribution` of
+  Boost.Multiprecision instead of Boost.Random; the sign of an integer is `integer_class::sign()` instead of
+  `boost::math::sign()`; the workaround for Boost releases older than 1.59 is compiled only when `BOOST_VERSION`
+  is defined (standalone Boost.Multiprecision does not define it).
+- `symengine/ntheory.cpp`: the includes of Boost.Random are removed.
+- `symengine/ntheory.cpp`: `mp_perfect_power_decomposition()` takes the p-th roots by `mp_root()` (Newton's method),
+  not by a binary search from 2 to n with the p-th power of each step, which took minutes for a number of 245 digits
+  (the logarithm of an integer in `refine()`, so in `simplify()`).
+- `symengine/mp_boost.cpp`: the include of `boost/mpl/int.hpp` is removed.
+
+### The powers taken out of the roots
+
+- `symengine/rational.cpp`: in an integer raised to a rational power, the powers of its factors are taken out of the
+  root, as SymPy does: `sqrt(8)` is `2*sqrt(2)`, `8^(1/4)` is `2^(3/4)`, `(-24)^(1/3)` is `2*(-3)^(1/3)`. SymEngine
+  took out only exact roots (`sqrt(4)` is `2`). The factors are found by trial division up to 2^15, and the rest of
+  the number when it is a perfect power.
+
+### The values of the functions
+
+- `symengine/special_double.h` (added): the special functions in double precision, for real and complex arguments,
+  where SymEngine relies on MPFR and Arb: gamma (Lanczos) and log gamma (Stirling's series, the branch of its analytic
+  continuation), zeta and the Hurwitz zeta (Euler-Maclaurin, the reflection formula), the Lambert W function (its
+  principal branch), polygamma, the incomplete gamma functions (of any real `s`: `E1` and the recurrences below 0),
+  beta, erf and erfc of complex numbers.
+- `symengine/special_boost.cpp` (added): the special functions of real arguments by Boost.Math (standalone, with the
+  policy of `native/config/boost_math_policy.h`: NaN or infinities instead of exceptions, doubles computed in doubles),
+  declared in `special_double.h` and used there wherever Boost.Math defines them: gamma, log gamma, polygamma, the
+  Riemann zeta function, the principal branch of the Lambert W function, erf, erfc, the incomplete gamma functions of
+  `s > 0` and beta of positive arguments. They are the same code on every platform, where `std::tgamma`, `std::lgamma`
+  and `std::erf` were those of each C library (`eval_double.cpp` and `lambda_double.h` now call them as well). The
+  incomplete gamma functions of `s <= 0`, beta of arguments that are not positive, the Hurwitz zeta function and the
+  complex arguments stay computed in `special_double.h`.
+- `symengine/eval_double.cpp`, `symengine/lambda_double.h`: these functions, with sign, floor, ceiling, truncation and
+  the conjugate, evaluated numerically and in the compiled functions. The complex values have no negative zeros, so that
+  a negative real number stays on the upper side of the branch cuts, as the exact values: `(0.9 + 0i)/(-0.4 + 0i)` is
+  `-2.25 - 0i` in floating point, and its logarithm was `-i*pi`. The integer powers are computed by multiplications and
+  the square roots by `sqrt`, in the powers and in the factors of the compiled products: `pow` goes through `exp` and
+  `log`, whose rounding moved real values off the real line. Log gamma has no real value left of zero (its imaginary
+  part is a multiple of pi), and the sign of NaN is NaN, so that the complex value is computed instead. `atan2(-0.0, x)`
+  is `atan2(0, x)`, as the exact value. The inverse trigonometric and hyperbolic functions of a real argument inside
+  their real domain are computed with their real versions in the complex evaluations: libc++'s complex `atan` of `-0.4`
+  has an imaginary part of `5.55e-17`, which put `arg(1/atan(-2/5))` at `-pi`. A value on a branch cut is moved to the
+  side the exact values take (SymPy's, counter-clockwise continuous, on which `asinh(-z) = -asinh(z)` relies) before the
+  complex function reads the side from the sign of a zero: `asin`, `acos` and `atanh` right of 1 from below; `atan` and
+  `asinh` below `-i` from the left. The reciprocal of the argument of `asec`, `acsc`, `acot`, `asech`, `acsch` and
+  `acoth` has no negative zero either (`1/(-0.5 + 0i)` is `-2 - 0i`, which put `asec(-1/2)` on the other side). The
+  maximum and the minimum of values one of which is NaN are NaN (`std::max` dropped a NaN after the first value, so the
+  complex evaluation was not tried); the complex evaluations have them too, for values of imaginary parts 0.
+- `symengine/functions.cpp`: polygamma has its poles at the nonpositive integers only (SymEngine gave
+  `complexInfinity` for every number not positive), a negative rational is moved right by the recurrence, and its
+  special values of the thirds and the quarters are chosen by the remainder of the numerator (`polygamma(0, 5/4)` was
+  wrong). `beta(x, 1 - x)` is `pi/sin(pi*x)` (it was `complexInfinity`). The sign of a product is the product of the
+  signs of its factors where they are known, the sign of a number written as an expression is computed
+  (`sign(pi - 3)` is 1), and the sign of a power of an unknown sign no longer recurses without end. The floor, the
+  ceiling and the truncation of a number written as an expression are computed (`floor(sqrt(2))` is 1); the
+  truncation no longer takes an integer out of a sum (`trunc(5 - 1/2)` is 4, not `5 + trunc(-1/2)`).
+- `symengine/functions.cpp`: the gamma function of a half-integer computes its double factorial in an integer of any
+  size (an `int` overflowed: `gamma(-25/2)` was wrong).
+- `symengine/functions.cpp`: the upper incomplete gamma function of an integer `s` below 1 stays an upper incomplete
+  gamma function: SymEngine made it the lower one (`uppergamma(0, 1)` was `lowergamma(0, 1)`).
+- `symengine/solve.cpp`: an equation that is not a polynomial in the variable is left unsolved (a condition set):
+  SymEngine failed on `sin(x) + x = 0`, and took a function of the variable as a coefficient, so that `x^x = 2` was
+  answered with no solution. A product with a denominator is solved as a fraction, so that the zeros of the denominator
+  are not solutions (`(x^2 - 1)/(x - 1) = 0` is `x = -1` only).
+- `symengine/derivative.cpp`: the derivative of `acosh(x)` is `1/(sqrt(x - 1)*sqrt(x + 1))`, as SymPy;
+  `1/sqrt(x^2 - 1)` has the wrong sign left of -1. The derivatives of gamma and log gamma are 0 when their argument
+  has no variable, decided before `polygamma(0, a)` is built: its exact value at an integer `a` is a harmonic number of
+  `a - 1` terms.
+  The derivative of an unevaluated expression (the rewritings leave them: `sin(x)` rewritten with `cos` is
+  `cos(x - pi/2)`) is the derivative of what it holds; it was an unevaluated derivative object.
+
+### The functions of the addon
+
+The functions SymEngine does not have (`cbrt` and `root` as real roots, in `native/functions`) are written as its
+function wrappers (`FunctionWrapper`).
+
+- `symengine/functions.h`, `symengine/functions.cpp`: a wrapper gives its value for numbers (`evaluate_real`,
+  `evaluate_complex`, by `create()` and `eval()` unless it overrides them), and a wrapper is equal to a wrapper of the
+  same type, name and arguments: `FunctionSymbol::__eq__` required the other object to be a plain function symbol,
+  so a wrapper was never equal to anything, not even itself (`cos(cbrt(x))` recursed without end).
+- `symengine/lambda_double.h`: the compiled functions call the wrappers with the values of their arguments.
+
+### Canonical forms
+
+- `symengine/mul.cpp`: the coefficient of a product goes into its first sum to the power 1 (`2*(x + 1)` is
+  `2*x + 2`, `2*(x + 1)/y` is `(2*x + 2)/y`), else the denominator of a rational coefficient goes into its first sum
+  to the power -1 (`z/(2*(x + 1))` is `z/(2*x + 2)`), as the formulas are read: a value has one form, the sums stay
+  flat. A factor that is a power, raised to an integer power, is combined (`(a^b)^n` is `a^(b*n)`).
+- `symengine/logic.cpp`: `piecewise()` gives nan where no case holds, as SymPy does; it threw ("piecewise undefined for
+  this domain"), so that a substitution outside the cases of a piecewise expression failed.
+- `symengine/mul.cpp`: the positive integers to the same rational power in a product are multiplied together, as in
+  SymPy: `sqrt(2)*sqrt(3)` is `sqrt(6)` (SymEngine kept the two, and a value written both ways could not be shown
+  equal), `2^(1/3)*4^(1/3)` is 2; powers that differ stay (`2^(1/3)*3^(2/3)`).
+- `symengine/add.cpp`: a number times a sum met as a term of a sum is multiplied out too, as in a product (a
+  substitution of `x = 1 - u` in `-x + 1` gave `-(-u + 1) + 1`, now `u`); also when it is the term of a product of a
+  number and a sum (the factored form `2*(x + 1)` of `factor()`), and in `add(a, b)`, which now adds its terms through
+  it (`2*(x + 1) + 1` is `2*x + 3`, not a sum inside a sum).
+- `symengine/functions.cpp`: the minus taken out of a sum (`asinh(-x - 1)` is `-asinh(x + 1)`) is added term by
+  term, so that a sum among the terms is flattened. `log(e^r)` is `r` for an exact real number `r`. The numeric factor
+  of a product is taken out of `abs` (`abs(-2*x)` is `2*abs(x)`), and `abs` is evaluated again once the minus is
+  taken out (`abs(-abs(x))` is `abs(x)`).
+- `symengine/numer_denom.cpp`: a power that is not an integer one is split over the fraction of its base only when
+  its denominator is positive: `sqrt(a/y)` is not `sqrt(a)/sqrt(y)`, and `(1/y)^x` is not `1/y^x`, when `y` is
+  negative.
+- `symengine/pow.cpp`: `e^log(x)` is `x`, and `e^(c*log(x))` is `x^c` for a number `c`, as SymPy. `(x^-1)^b` stays
+  as written: SymEngine made it `x^(-b)`, which is wrong for a negative `x` when `b` is not an integer
+  (`sqrt(1/(-4))` is `i/2`, `1/sqrt(-4)` is `-i/2`). `1` to any exact power is `1` (`1^(10^20)` failed).
+
+### The size of the exact numbers
+
+- `symengine/limits.h` (added), `symengine/pow.cpp`, `symengine/mul.cpp`, `symengine/rational.cpp`,
+  `symengine/integer.h`, `symengine/rational.h`: a power whose result would have more than 2^20 bits (about 315000
+  digits) stays a power, where SymEngine computed it (hours, and all the memory, for `(3/20)^(10^8)`); the other
+  operations reaching such a power fail instead of hanging. The gamma function of an integer above 20001 (its
+  factorial) stays as written, as the factorials of the parser, and so does polygamma at such an integer.
+- `symengine/mp_boost.cpp`: the integer roots start from an upper bound of the root (SymEngine started from 1, and a
+  root of order 10^16 never ended); the factorials and the binomial coefficients are products of a product tree
+  (SymEngine multiplied one factor at a time).
+- `symengine/rational.cpp`: the powers taken out of the roots only for roots up to 2^15 and numbers of a bounded size.
+
+### Used by several threads, and while the process exits
+
+The addon runs SymEngine in its own threads, which can still be running when the process exits.
+
+- `symengine/constants.cpp`: the constants (`zero`, `one`, `pi`…) are never destroyed. Their destructors used to run
+  at exit while the threads were still using them, and the process crashed.
+- `symengine/eval_double.cpp`, `symengine/functions.cpp`, `symengine/printers/strprinter.cpp`: the static tables are
+  allocated once and never destroyed, for the same reason.
+- `symengine/prime_sieve.cpp`: each thread has its own cache of primes. SymEngine shared one vector between all
+  threads and extended and cleared it without a lock.
+- `symengine/interruption.h`, `symengine/interruption.cpp` (added): a function the addon sets, called at each step of
+  the long loops of `symengine/expand.cpp` and of the multinomial coefficients of `symengine/pow.cpp`. It throws when
+  the operation is cancelled or past its time limit, so that its thread stops there.
+
+SymEngine's own tests, built by its CMake (`INTEGER_CLASS=boostmp`, the headers of Boost from `vendor/`) on its 0.15.0
+release with the sources of `vendor/` over it (2026-10-28, for the patch of `add.cpp`): 56 of its 60 tests pass. The 10
+assertions that fail, in `test_functions`, `test_printing`, `test_eval_double` and `test_cwrapper`, check the forms that
+the patches above change on purpose (a coefficient multiplied into a sum, the minus taken out of `acosh`, `truncate` of
+a sum, `zeta` evaluated by Boost.Math, the printing of the C wrapper); they are the same with and without the patch of
+`add.cpp`. The patch of the powers in `mul.cpp` (2026-10-28) adds one, in `test_printing`, which expects
+`23*sqrt(5)*sqrt(7)` where it is now `23*sqrt(35)`. The patch of `logic.cpp` (2026-10-28) makes `test_logic` fail at its
+one assertion that `piecewise()` throws where no case holds.
+
+## Boost.Math
+
+- `include/boost/math/distributions/hypergeometric.hpp`: `kurtosis_excess()` returned the kurtosis of Wolfram's formula,
+  which is the full one, and `kurtosis()` added 3 to it: the excess is now 3 less (SciPy's: -0.1527 for 12 draws from
+  20 items of which 7 are successes, where Boost gave 2.8473).
+
+## Eigen
+
+- `Eigen/src/IterativeLinearSolvers/BiCGSTAB.h`: the loop compared the norm of the residual itself with the tolerance,
+  which is relative (the error it returns is the norm of the residual over the norm of the right side): for a right
+  side of norm below 1 it stopped before the tolerance and reported `NoConvergence` (a residual of 9e-11 for a right
+  side of norm 0.38, the fuzz). It compares the residual with the tolerance times the norm of the right side.

package/vendor/boost/config/README.md

@@ -0,0 +1,43 @@
+Boost Config Library
+============================
+
+This library provides configuration support for the Boost C++ libraries.
+
+The full documentation is available on [boost.org](http://www.boost.org/doc/libs/release/libs/config/index.html).
+
+|                  |  Master  |   Develop   |
+|------------------|----------|-------------|
+| Drone            |  [![Build Status](https://drone.cpp.al/api/badges/boostorg/config/status.svg?ref=refs/heads/master)](https://drone.cpp.al/boostorg/config) | [![Build Status](https://drone.cpp.al/api/badges/boostorg/config/status.svg)](https://drone.cpp.al/boostorg/config) |
+| Travis           | [![Build Status](https://travis-ci.org/boostorg/config.svg?branch=master)](https://travis-ci.org/boostorg/config)  |  [![Build Status](https://travis-ci.org/boostorg/config.png)](https://travis-ci.org/boostorg/config) |
+| Appveyor         | [![Build status](https://ci.appveyor.com/api/projects/status/wo2n2mhoy8vegmuo/branch/master?svg=true)](https://ci.appveyor.com/project/jzmaddock/config/branch/master) | [![Build status](https://ci.appveyor.com/api/projects/status/wo2n2mhoy8vegmuo/branch/develop?svg=true)](https://ci.appveyor.com/project/jzmaddock/config/branch/develop) |
+
+## Support, bugs and feature requests ##
+
+Bugs and feature requests can be reported through the [Gitub issue tracker](https://github.com/boostorg/config/issues)
+(see [open issues](https://github.com/boostorg/config/issues) and
+[closed issues](https://github.com/boostorg/config/issues?utf8=%E2%9C%93&q=is%3Aissue+is%3Aclosed)).
+
+You can submit your changes through a [pull request](https://github.com/boostorg/config/pulls).
+
+There is no mailing-list specific to Boost Config, although you can use the general-purpose Boost [mailing-list](http://lists.boost.org/mailman/listinfo.cgi/boost-users) using the tag [config].
+
+
+## Development ##
+
+Clone the whole boost project, which includes the individual Boost projects as submodules ([see boost+git doc](https://github.com/boostorg/boost/wiki/Getting-Started)): 
+
+    git clone https://github.com/boostorg/boost
+    cd boost
+    git submodule update --init
+
+The Boost Config Library is located in `libs/config/`. 
+
+### Running tests ###
+First, make sure you are in `libs/config/test`. 
+You can either run all the tests listed in `Jamfile.v2` or run a single test:
+
+    ../../../b2                        <- run all tests
+    ../../../b2 config_info            <- single test
+
+### For developers ###
+Please check the [Guidelines for Boost Authors](http://www.boost.org/doc/libs/release/libs/config/doc/html/boost_config/guidelines_for_boost_authors.html). from the full documentation.

package/vendor/boost/config/include/boost/config/abi/borland_prefix.hpp

@@ -0,0 +1,27 @@
+//  (C) Copyright John Maddock 2003. 
+//  Use, modification and distribution are subject to the 
+//  Boost Software License, Version 1.0. (See accompanying file 
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+//  for C++ Builder the following options effect the ABI:
+//
+//  -b (on or off - effect emum sizes)
+//  -Vx  (on or off - empty members)
+//  -Ve (on or off - empty base classes)
+//  -aX (alignment - 5 options).
+//  -pX (Calling convention - 4 options)
+//  -VmX (member pointer size and layout - 5 options)
+//  -VC (on or off, changes name mangling)
+//  -Vl (on or off, changes struct layout).
+
+//  In addition the following warnings are sufficiently annoying (and
+//  unfixable) to have them turned off by default:
+//
+//  8027 - functions containing [for|while] loops are not expanded inline
+//  8026 - functions taking class by value arguments are not expanded inline
+
+#pragma nopushoptwarn
+#  pragma option push -a8 -Vx- -Ve- -b- -pc -Vmv -VC- -Vl- -w-8027 -w-8026
+
+
+