@lakutata/math 0.0.0-stage → 3.1.5

package/dist/esm/exceptions/MathArgumentException.js

@@ -0,0 +1,14 @@
+import { MathException } from './MathException.js';
+/**
+ * An argument that is not valid: an expression with variables where a number is asked, a name that is not a variable, a
+ * number of values that does not match. Its `errno` is `'E_MATH_ARGUMENT'`.
+ */
+export class MathArgumentException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_ARGUMENT'`.
+         */
+        this.errno = 'E_MATH_ARGUMENT';
+    }
+}

package/dist/esm/exceptions/MathCancelledException.js

@@ -0,0 +1,13 @@
+import { MathException } from './MathException.js';
+/**
+ * An asynchronous operation cancelled by its `signal`. Its `errno` is `'E_MATH_CANCELLED'`.
+ */
+export class MathCancelledException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_CANCELLED'`.
+         */
+        this.errno = 'E_MATH_CANCELLED';
+    }
+}

package/dist/esm/exceptions/MathDefinitionException.js

@@ -0,0 +1,14 @@
+import { MathException } from './MathException.js';
+/**
+ * A definition of `createMath()` (or of `with()`) is not valid: a name already used by the formulas, a parameter given
+ * twice, definitions referring to each other in a cycle. Its `errno` is `'E_MATH_DEFINITION'`.
+ */
+export class MathDefinitionException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_DEFINITION'`.
+         */
+        this.errno = 'E_MATH_DEFINITION';
+    }
+}

package/dist/esm/exceptions/MathDivisionByZeroException.js

@@ -0,0 +1,13 @@
+import { MathException } from './MathException.js';
+/**
+ * A division by zero. Its `errno` is `'E_MATH_DIVISION_BY_ZERO'`.
+ */
+export class MathDivisionByZeroException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_DIVISION_BY_ZERO'`.
+         */
+        this.errno = 'E_MATH_DIVISION_BY_ZERO';
+    }
+}

package/dist/esm/exceptions/MathDomainException.js

@@ -0,0 +1,14 @@
+import { MathException } from './MathException.js';
+/**
+ * A value is out of the domain of an operation: a complex value where a real number is asked, the logarithm of a
+ * negative number in decimals. Its `errno` is `'E_MATH_DOMAIN'`.
+ */
+export class MathDomainException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_DOMAIN'`.
+         */
+        this.errno = 'E_MATH_DOMAIN';
+    }
+}

package/dist/esm/exceptions/MathException.js

@@ -0,0 +1,18 @@
+/**
+ * The base of the exceptions of the package: catch it for any of them. Its `errno` is `'E_MATH_INTERNAL'` for an
+ * internal error of the addon, the one of the subclass otherwise; its `name` is the name of its class.
+ */
+export class MathException extends Error {
+    /**
+     * An exception of a message.
+     * @param message The message.
+     */
+    constructor(message) {
+        super(message);
+        /**
+         * `'E_MATH_INTERNAL'`, or the one of the subclass.
+         */
+        this.errno = 'E_MATH_INTERNAL';
+        this.name = new.target.name;
+    }
+}

package/dist/esm/exceptions/MathNotSupportedException.js

@@ -0,0 +1,14 @@
+import { MathException } from './MathException.js';
+/**
+ * An operation the package does not do, or not for this expression (an integral without elementary form, a function
+ * that cannot be compiled). Its `errno` is `'E_MATH_NOT_SUPPORTED'`.
+ */
+export class MathNotSupportedException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_NOT_SUPPORTED'`.
+         */
+        this.errno = 'E_MATH_NOT_SUPPORTED';
+    }
+}

package/dist/esm/exceptions/MathSyntaxException.js

@@ -0,0 +1,14 @@
+import { MathException } from './MathException.js';
+/**
+ * A formula is not written correctly: its `position` is the index of the character where the error is found. Its
+ * `errno` is `'E_MATH_SYNTAX'`.
+ */
+export class MathSyntaxException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_SYNTAX'`.
+         */
+        this.errno = 'E_MATH_SYNTAX';
+    }
+}

package/dist/esm/exceptions/MathTimeoutException.js

@@ -0,0 +1,13 @@
+import { MathException } from './MathException.js';
+/**
+ * An asynchronous operation that took longer than its `timeout`. Its `errno` is `'E_MATH_TIMEOUT'`.
+ */
+export class MathTimeoutException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_TIMEOUT'`.
+         */
+        this.errno = 'E_MATH_TIMEOUT';
+    }
+}

package/dist/esm/exceptions/MathUnitException.js

@@ -0,0 +1,14 @@
+import { MathException } from './MathException.js';
+/**
+ * Units that do not match: a length added to a time, a conversion between dimensions that differ. Its `errno` is
+ * `'E_MATH_UNIT'`.
+ */
+export class MathUnitException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_UNIT'`.
+         */
+        this.errno = 'E_MATH_UNIT';
+    }
+}

package/dist/esm/exceptions/MathUnknownFunctionException.js

@@ -0,0 +1,15 @@
+import { MathException } from './MathException.js';
+/**
+ * A formula calls a function that is neither one of the formulas nor defined (`foo(x)`), or writes a constant as a call
+ * (`g(2)`): to multiply, write `foo*(x)`. Its `position` is the index of the name. Its `errno` is
+ * `'E_MATH_UNKNOWN_FUNCTION'`.
+ */
+export class MathUnknownFunctionException extends MathException {
+    constructor() {
+        super(...arguments);
+        /**
+         * `'E_MATH_UNKNOWN_FUNCTION'`.
+         */
+        this.errno = 'E_MATH_UNKNOWN_FUNCTION';
+    }
+}

package/dist/esm/exports/Math.js

@@ -0,0 +1,26 @@
+export { MathException } from '../exceptions/MathException.js';
+export { MathSyntaxException } from '../exceptions/MathSyntaxException.js';
+export { MathUnknownFunctionException } from '../exceptions/MathUnknownFunctionException.js';
+export { MathDefinitionException } from '../exceptions/MathDefinitionException.js';
+export { MathDomainException } from '../exceptions/MathDomainException.js';
+export { MathDivisionByZeroException } from '../exceptions/MathDivisionByZeroException.js';
+export { MathNotSupportedException } from '../exceptions/MathNotSupportedException.js';
+export { MathUnitException } from '../exceptions/MathUnitException.js';
+export { MathCancelledException } from '../exceptions/MathCancelledException.js';
+export { MathTimeoutException } from '../exceptions/MathTimeoutException.js';
+export { MathArgumentException } from '../exceptions/MathArgumentException.js';
+export { Equation, Expression, Inequality, Solutions } from '../lib/Expression.js';
+export { Decimal } from '../lib/Decimal.js';
+export { LinearAlgebra } from '../lib/LinearAlgebra.js';
+export { Matrix } from '../lib/Matrix.js';
+export { SparseMatrix } from '../lib/SparseMatrix.js';
+export { Statistics } from '../lib/Statistics.js';
+export { Distribution, RandomGenerator } from '../lib/Distribution.js';
+export { Numeric } from '../lib/Numeric.js';
+export { createMath, MathScope } from '../lib/MathScope.js';
+export { constant, cse, cseAsync, decimal, equation, expression, expressionMatrix, finiteSet, interval, jacobian, linalg, math, matrix, ntheory, numeric, parse, poly, solve, solveAsync, stats, unit } from '../lib/Defaults.js';
+export { MathSet } from '../lib/MathSet.js';
+export { Polynomials } from '../lib/Polynomials.js';
+export { Unit } from '../lib/Unit.js';
+export { ExpressionMatrix } from '../lib/ExpressionMatrix.js';
+export { NumberTheory } from '../lib/NumberTheory.js';

package/dist/esm/lib/Addon.js

@@ -0,0 +1,10 @@
+import {createRequire} from 'node:module';
+import {fileURLToPath} from 'node:url';
+let loaded;
+try {
+    loaded = createRequire(import.meta.url)(fileURLToPath(new URL('../../../build/Release/math.node', import.meta.url)));
+} catch (error) {
+    if (error?.code === 'MODULE_NOT_FOUND') throw new Error("The addon of @lakutata/math (build/Release/math.node) is not built: the install script of the package did not run. Bun and pnpm run it only for the dependencies they trust (trustedDependencies in the package.json for Bun, pnpm approve-builds for pnpm): allow it, then install again or run npm rebuild @lakutata/math.", {cause: error});
+    throw error;
+}
+export const addon = loaded;

package/dist/esm/lib/Context.js

@@ -0,0 +1,128 @@
+import { MathArgumentException } from '../exceptions/MathArgumentException.js';
+import { MathCancelledException } from '../exceptions/MathCancelledException.js';
+import { MathTimeoutException } from '../exceptions/MathTimeoutException.js';
+import { nativeCall, toException } from './Native.js';
+/**
+ * The asynchronous operations of a scope of `createMath()` and of the scopes of its `with()`: how many run at a time
+ * in the threads of the addon. An operation keeps its place until its thread is done with it, even when its promise is
+ * already rejected (a time limit, a cancellation).
+ */
+export class AsyncTracker {
+    #waiting = [];
+    #active = 0;
+    constructor(concurrency) {
+        this.concurrency = concurrency;
+    }
+    /**
+     * Wait for a free place
+     */
+    async acquire() {
+        if (this.#active >= this.concurrency)
+            await new Promise((resolve) => this.#waiting.push(resolve));
+        this.#active++;
+    }
+    /**
+     * Free a place
+     */
+    release() {
+        this.#active--;
+        this.#waiting.shift()?.();
+    }
+    /**
+     * Keep a place until an operation is done in its thread
+     * @param running
+     */
+    hold(running) {
+        running.then(() => undefined, () => undefined).finally(() => this.release());
+    }
+}
+/**
+ * A context of the formulas: a scope of definitions, the settings and the tracker of its operations, its units.
+ * `createMath()` makes one; each `with()` makes another over it.
+ */
+export class Context {
+    constructor(scope, settings, tracker, units) {
+        this.scope = scope;
+        this.settings = settings;
+        this.tracker = tracker;
+        this.units = units;
+    }
+    /**
+     * A context over this one, its definitions added
+     * @param definitions
+     */
+    derive(definitions) {
+        return new Context(nativeCall((native) => native.scope(this.scope, definitionsOf(definitions))), this.settings, this.tracker, this.units);
+    }
+    /**
+     * Run an operation of the addon in its threads
+     * @param operation
+     * @param args
+     * @param options
+     */
+    async runAsync(operation, args, options = {}) {
+        const signal = options.signal;
+        if (signal?.aborted)
+            throw new MathCancelledException('The operation is cancelled');
+        await this.tracker.acquire();
+        if (signal?.aborted) {
+            this.tracker.release();
+            throw new MathCancelledException('The operation is cancelled');
+        }
+        let token;
+        let running;
+        try {
+            token = nativeCall((native) => native.token());
+            running = nativeCall((native) => native.runAsync(operation, args, token));
+        }
+        catch (error) {
+            this.tracker.release();
+            throw error;
+        }
+        this.tracker.hold(running);
+        //Rejected at the time limit or the cancellation: the thread stops at its next checkpoint, or finishes first
+        return await new Promise((resolve, reject) => {
+            const timeout = options.timeout ?? this.settings.timeout;
+            let timer;
+            const finish = () => {
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', abort);
+            };
+            const stop = (reason, exception) => {
+                finish();
+                nativeCall((native) => native.cancel(token, reason));
+                reject(exception);
+            };
+            const abort = () => stop('cancelled', new MathCancelledException('The operation is cancelled'));
+            if (timeout > 0)
+                timer = setTimeout(() => stop('timeout', new MathTimeoutException(`The operation took more than ${timeout} ms`)), timeout);
+            signal?.addEventListener('abort', abort, { once: true });
+            running.then((value) => {
+                finish();
+                resolve(value);
+            }, (error) => {
+                finish();
+                reject(toException(error));
+            });
+        });
+    }
+    /**
+     * Run an operation of the addon in the thread of JavaScript
+     * @param operation
+     * @param args
+     */
+    run(operation, args) {
+        return nativeCall((native) => native.run(operation, args));
+    }
+}
+/**
+ * The definitions of the configuration as the addon takes them: [signature, body] pairs
+ * @param definitions
+ */
+export function definitionsOf(definitions) {
+    return Object.entries(definitions).map(([signature, body]) => {
+        if (typeof body !== 'string' && typeof body !== 'number')
+            throw new MathArgumentException(`The definition ${signature}: its body is a formula (a string) or a number`);
+        return [signature, String(body)];
+    });
+}