@siteimprove/alfa-math 0.89.5

package/CHANGELOG.md

@@ -0,0 +1,151 @@
+# @siteimprove/alfa-math
+
+## 0.89.3
+
+## 0.89.2
+
+### Patch Changes
+
+- **Changed:** Trying to fix a problem in generating provenance statements ([#1674](https://github.com/Siteimprove/alfa/pull/1674))
+
+## 0.89.1
+
+### Patch Changes
+
+- **Added:** Trying to publish Alfa packages on the npm registry ([#1673](https://github.com/Siteimprove/alfa/pull/1673))
+
+## 0.89.0
+
+## 0.88.0
+
+### Minor Changes
+
+- **Fixed:** The publish flow was updated to a new version. ([`a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2`](https://github.com/Siteimprove/alfa/commit/a2f19cf9a6c7c72b8bf085597e4f1a95ac3e4eb2))
+
+  Some 0.87.\* versions were generating uninstallable package. This should be fixed now.
+
+## 0.87.12
+
+## 0.87.11
+
+## 0.87.10
+
+## 0.87.7
+
+## 0.87.6
+
+## 0.87.5
+
+## 0.87.4
+
+## 0.87.3
+
+## 0.87.2
+
+## 0.87.1
+
+## 0.87.0
+
+## 0.86.2
+
+## 0.86.1
+
+## 0.86.0
+
+### Minor Changes
+
+- **Breaking:** TS resolution has been changed to `Node16`, target to `es2022`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+- **Breaking:** Alfa is now distributed as ESM rather than CJS modules; projects using it must be ESM or use dynamic `import()`. ([#1636](https://github.com/Siteimprove/alfa/pull/1636))
+
+  ⚠️ This is the last of a series of changes on the internal structure and build process of distributed packages that was started with v0.85.0.
+
+## 0.85.1
+
+## 0.85.0
+
+### Minor Changes
+
+- **Breaking:** The .js files are now built in the `dist` folder rather than in `src`. ([#1628](https://github.com/Siteimprove/alfa/pull/1628))
+
+  ⚠️ This is the first of a series of changes on the internal structure and build process of distributed packages. It is probably better to not use this version and wait until more of these internal changes have been done to jump directly to the final result. We are internally releasing these changes for validation purpose only.
+
+  This should not impact consumers, the `package.json` files should be set correctly to consume these files.
+
+## 0.84.0
+
+## 0.83.1
+
+## 0.83.0
+
+## 0.82.0
+
+### Minor Changes
+
+- **Breaking:** Node 18 is no longer supported. ([#1618](https://github.com/Siteimprove/alfa/pull/1618))
+
+## 0.81.0
+
+### Patch Changes
+
+- **Added:** Each package now contains its internal dependency graph in its `docs` directory. ([#1610](https://github.com/Siteimprove/alfa/pull/1610))
+
+## 0.80.0
+
+## 0.79.1
+
+## 0.79.0
+
+## 0.78.2
+
+## 0.78.1
+
+## 0.78.0
+
+## 0.77.0
+
+## 0.76.0
+
+## 0.75.2
+
+## 0.75.1
+
+## 0.75.0
+
+## 0.74.0
+
+## 0.73.0
+
+## 0.72.0
+
+## 0.71.1
+
+## 0.71.0
+
+## 0.70.0
+
+## 0.69.0
+
+## 0.68.0
+
+## 0.67.0
+
+## 0.66.0
+
+## 0.65.1
+
+## 0.65.0
+
+## 0.64.0
+
+## 0.63.3
+
+## 0.63.2
+
+## 0.63.1
+
+## 0.63.0
+
+## 0.62.2
+
+## 0.62.1

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./matrix.js";
+export * from "./real.js";
+export * from "./vector.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -0,0 +1,4 @@
+export * from "./matrix.js";
+export * from "./real.js";
+export * from "./vector.js";
+//# sourceMappingURL=index.js.map

package/dist/matrix.d.ts

@@ -0,0 +1,57 @@
+/**
+ * {@link https://en.wikipedia.org/wiki/Matrix_(mathematics)}
+ *
+ * @public
+ */
+export type Matrix = Array<Array<number>>;
+/**
+ * @public
+ */
+export declare namespace Matrix {
+    function isMatrix(value: unknown): value is Matrix;
+    function isSquare(m: Matrix): boolean;
+    function clone(m: Matrix): Matrix;
+    function equals(m: Matrix, n: Matrix, e?: number): boolean;
+    function identity(n: number): Matrix;
+    function size(m: Matrix): [number, number];
+    function rows(m: Matrix): number;
+    function columns(m: Matrix): number;
+    function row(m: Matrix, i: number): Array<number>;
+    function column(m: Matrix, i: number): Array<number>;
+    function add(m: Matrix, n: Matrix): Matrix;
+    function subtract(m: Matrix, n: Matrix): Matrix;
+    /**
+     * {@link https://en.wikipedia.org/wiki/Matrix_multiplication}
+     */
+    function multiply(m: Matrix, n: number | Matrix): Matrix;
+    /**
+     * Compute the transpose of a matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Transpose}
+     */
+    function transpose(m: Matrix): Matrix;
+    /**
+     * Compute the determinant of a non-empty, square matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Determinant}
+     * {@link https://en.wikipedia.org/wiki/Laplace_expansion}
+     *
+     * @remarks
+     * This function uses Laplace expansion for computing the determinant which
+     * has a time complexity of O(n!) and is therefore not practical for large
+     * matrices.
+     */
+    function determinant(m: Matrix): number;
+    /**
+     * Compute the inverse of an invertible matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Invertible_matrix}
+     * {@link https://en.wikipedia.org/wiki/Cramers_rule}
+     *
+     * @remarks
+     * This function uses Cramer's rule for computing the inverse which has a time
+     * complexity of O(n!) and is therefore not practical for large matrices.
+     */
+    function inverse(m: Matrix): Matrix;
+}
+//# sourceMappingURL=matrix.d.ts.map

package/dist/matrix.js

@@ -0,0 +1,152 @@
+import { Real } from "./real.js";
+/**
+ * @public
+ */
+export var Matrix;
+(function (Matrix) {
+    function isMatrix(value) {
+        return (Array.isArray(value) &&
+            value.every((r) => Array.isArray(r) && r.every((v) => typeof v === "number")));
+    }
+    Matrix.isMatrix = isMatrix;
+    function isSquare(m) {
+        return rows(m) === columns(m);
+    }
+    Matrix.isSquare = isSquare;
+    function clone(m) {
+        return m.map((r) => r.slice(0));
+    }
+    Matrix.clone = clone;
+    function equals(m, n, e) {
+        return (m.length === n.length &&
+            m.every((r, i) => r.length === n[i].length &&
+                r.every((v, j) => Real.equals(v, n[i][j], e))));
+    }
+    Matrix.equals = equals;
+    function identity(n) {
+        return new Array(n).fill([]).map((_, i) => {
+            const r = new Array(n).fill(0);
+            r[i] = 1;
+            return r;
+        });
+    }
+    Matrix.identity = identity;
+    function size(m) {
+        return [rows(m), columns(m)];
+    }
+    Matrix.size = size;
+    function rows(m) {
+        return m.length;
+    }
+    Matrix.rows = rows;
+    function columns(m) {
+        return m.length === 0 ? 0 : m[0].length;
+    }
+    Matrix.columns = columns;
+    function row(m, i) {
+        return m[i];
+    }
+    Matrix.row = row;
+    function column(m, i) {
+        return m.map((r) => r[i]);
+    }
+    Matrix.column = column;
+    function add(m, n) {
+        return m.map((r, i) => r.map((v, j) => v + n?.[i]?.[j]));
+    }
+    Matrix.add = add;
+    function subtract(m, n) {
+        return m.map((r, i) => r.map((v, j) => v - n?.[i]?.[j]));
+    }
+    Matrix.subtract = subtract;
+    /**
+     * {@link https://en.wikipedia.org/wiki/Matrix_multiplication}
+     */
+    function multiply(m, n) {
+        return typeof n === "number"
+            ? m.map((r) => r.map((v) => v * n))
+            : m.map((r, i) => n[0].map((_, j) => r.reduce((s, _, k) => s + m[i][k] * n?.[k]?.[j], 0)));
+    }
+    Matrix.multiply = multiply;
+    /**
+     * Compute the transpose of a matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Transpose}
+     */
+    function transpose(m) {
+        return m.length === 0 ? m : m[0].map((_, i) => m.map((row) => row[i]));
+    }
+    Matrix.transpose = transpose;
+    /**
+     * Compute the determinant of a non-empty, square matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Determinant}
+     * {@link https://en.wikipedia.org/wiki/Laplace_expansion}
+     *
+     * @remarks
+     * This function uses Laplace expansion for computing the determinant which
+     * has a time complexity of O(n!) and is therefore not practical for large
+     * matrices.
+     */
+    function determinant(m) {
+        switch (m.length) {
+            // The determinant of a 1x1 matrix is the single value of the matrix.
+            case 1:
+                return m[0][0];
+            // The determinant of a 2x2 matrix is fairly short to write out and so
+            // this is done as an optimization.
+            case 2:
+                return m[0]?.[0] * m[1]?.[1] - m[0]?.[1] * m[1]?.[0];
+            default:
+                return m.reduce((d, _, i) => d + m[0]?.[i] * cofactor(m, 0, i), 0);
+        }
+    }
+    Matrix.determinant = determinant;
+    /**
+     * Compute the inverse of an invertible matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Invertible_matrix}
+     * {@link https://en.wikipedia.org/wiki/Cramers_rule}
+     *
+     * @remarks
+     * This function uses Cramer's rule for computing the inverse which has a time
+     * complexity of O(n!) and is therefore not practical for large matrices.
+     */
+    function inverse(m) {
+        return multiply(adjugate(m), 1 / determinant(m));
+    }
+    Matrix.inverse = inverse;
+    /**
+     * Compute the (i, j) cofactor of a non-empty, square matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Minor_(linear_algebra)}
+     * @internal
+     */
+    function cofactor(m, i, j) {
+        return (-1) ** (i + j) * minor(m, i, j);
+    }
+    /**
+     * Compute the (i, j) minor of a non-empty, square matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Minor_(linear_algebra)}
+     * @internal
+     */
+    function minor(m, i, j) {
+        return determinant(m
+            // Remove the i-th row
+            .filter((_, k) => k !== i)
+            .map((r) => r
+            // Remove the j-th column
+            .filter((_, l) => l !== j)));
+    }
+    /**
+     * Compute the adjugate of a non-empty, square matrix.
+     *
+     * {@link https://en.wikipedia.org/wiki/Adjugate_matrix}
+     * @internal
+     */
+    function adjugate(m) {
+        return transpose(m.map((r, i) => r.map((_, j) => cofactor(m, i, j))));
+    }
+})(Matrix || (Matrix = {}));
+//# sourceMappingURL=matrix.js.map

package/dist/real.d.ts

@@ -0,0 +1,37 @@
+/**
+ * {@link https://en.wikipedia.org/wiki/Real_number}
+ *
+ * @public
+ */
+export declare namespace Real {
+    function isReal(value: number): boolean;
+    function isReal(value: unknown): value is number;
+    function add(p: number, q: number): number;
+    function subtract(p: number, q: number): number;
+    function multiply(p: number, q: number): number;
+    function divide(p: number, d: number): number;
+    /**
+     * Compute the modulus of a division of two reals.
+     *
+     * {@link https://en.wikipedia.org/wiki/Modulo_operation}
+     *
+     * @remarks
+     * The modulo operation is different from the remainder operation supported
+     * natively in JavaScript through the % operator.
+     */
+    function modulo(p: number, d: number): number;
+    /**
+     * Clamp a real between a lower and an upper value.
+     */
+    function clamp(p: number, l: number, u: number): number;
+    /**
+     * Round a real to a given number of decimals.
+     */
+    function round(p: number, n?: number): number;
+    /**
+     * Check if two reals are equal, accounting for floating-point precision
+     * errors according to a given epsilon.
+     */
+    function equals(a: number, b: number, e?: number): boolean;
+}
+//# sourceMappingURL=real.d.ts.map

package/dist/real.js

@@ -0,0 +1,72 @@
+const { abs, min, max } = Math;
+/**
+ * {@link https://en.wikipedia.org/wiki/Real_number}
+ *
+ * @public
+ */
+export var Real;
+(function (Real) {
+    function isReal(value) {
+        return typeof value === "number" && Number.isFinite(value);
+    }
+    Real.isReal = isReal;
+    function add(p, q) {
+        return p + q;
+    }
+    Real.add = add;
+    function subtract(p, q) {
+        return p - q;
+    }
+    Real.subtract = subtract;
+    function multiply(p, q) {
+        return p * q;
+    }
+    Real.multiply = multiply;
+    function divide(p, d) {
+        return p / d;
+    }
+    Real.divide = divide;
+    /**
+     * Compute the modulus of a division of two reals.
+     *
+     * {@link https://en.wikipedia.org/wiki/Modulo_operation}
+     *
+     * @remarks
+     * The modulo operation is different from the remainder operation supported
+     * natively in JavaScript through the % operator.
+     */
+    function modulo(p, d) {
+        return ((p % d) + d) % d;
+    }
+    Real.modulo = modulo;
+    /**
+     * Clamp a real between a lower and an upper value.
+     */
+    function clamp(p, l, u) {
+        return max(l, min(p, u));
+    }
+    Real.clamp = clamp;
+    /**
+     * Round a real to a given number of decimals.
+     */
+    function round(p, n = 0) {
+        return n === 0 ? Math.round(p) : Math.round(p * 10 ** n) / 10 ** n;
+    }
+    Real.round = round;
+    /**
+     * Check if two reals are equal, accounting for floating-point precision
+     * errors according to a given epsilon.
+     */
+    function equals(a, b, e = Number.EPSILON) {
+        if (a === b) {
+            return true;
+        }
+        const diff = abs(a - b);
+        if (a === 0 || b === 0) {
+            return diff < e;
+        }
+        return diff / min(abs(b) + abs(a), Number.MAX_VALUE) < e;
+    }
+    Real.equals = equals;
+})(Real || (Real = {}));
+//# sourceMappingURL=real.js.map

package/dist/vector.d.ts

@@ -0,0 +1,44 @@
+/**
+ * {@link https://en.wikipedia.org/wiki/Vector_(mathematics_and_physics)}
+ *
+ * @public
+ */
+export type Vector = Array<number>;
+/**
+ * @public
+ */
+export declare namespace Vector {
+    function isVector(value: unknown): value is Vector;
+    function clone(v: Vector): Vector;
+    function equals(v: Vector, u: Vector, e: number): boolean;
+    function size(v: Vector): number;
+    function add(v: Vector, u: Vector): Vector;
+    function subtract(v: Vector, u: Vector): Vector;
+    function multiply(v: Vector, s: number): Vector;
+    function divide(v: Vector, d: number): Vector;
+    /**
+     * Compute the dot product of two non-empty, equal length vectors.
+     *
+     * {@link https://en.wikipedia.org/wiki/Dot_product}
+     */
+    function dot(v: Vector, u: Vector): number;
+    /**
+     * Compute the cross product of two 3-dimensional vectors.
+     *
+     * {@link https://en.wikipedia.org/wiki/Cross_product}
+     */
+    function cross(v: Vector, u: Vector): Vector;
+    /**
+     * Compute the norm of a vector.
+     *
+     * {@link https://en.wikipedia.org/wiki/Norm_(mathematics)}
+     */
+    function norm(v: Vector): number;
+    /**
+     * Compute a unit vector corresponding to a vector.
+     *
+     * {@link https://en.wikipedia.org/wiki/Unit_vector}
+     */
+    function normalize(v: Vector): Vector;
+}
+//# sourceMappingURL=vector.d.ts.map

package/dist/vector.js

@@ -0,0 +1,79 @@
+import { Real } from "./real.js";
+const { sqrt } = Math;
+/**
+ * @public
+ */
+export var Vector;
+(function (Vector) {
+    function isVector(value) {
+        return Array.isArray(value) && value.every((n) => typeof n === "number");
+    }
+    Vector.isVector = isVector;
+    function clone(v) {
+        return v.slice(0);
+    }
+    Vector.clone = clone;
+    function equals(v, u, e) {
+        return v.length === u.length && v.every((n, i) => Real.equals(n, u[i], e));
+    }
+    Vector.equals = equals;
+    function size(v) {
+        return v.length;
+    }
+    Vector.size = size;
+    function add(v, u) {
+        return v.map((n, i) => n + u?.[i]);
+    }
+    Vector.add = add;
+    function subtract(v, u) {
+        return v.map((n, i) => n - u?.[i]);
+    }
+    Vector.subtract = subtract;
+    function multiply(v, s) {
+        return v.map((n) => n * s);
+    }
+    Vector.multiply = multiply;
+    function divide(v, d) {
+        return v.map((n) => n / d);
+    }
+    Vector.divide = divide;
+    /**
+     * Compute the dot product of two non-empty, equal length vectors.
+     *
+     * {@link https://en.wikipedia.org/wiki/Dot_product}
+     */
+    function dot(v, u) {
+        return v.reduce((s, n, i) => s + n * u?.[i], 0);
+    }
+    Vector.dot = dot;
+    /**
+     * Compute the cross product of two 3-dimensional vectors.
+     *
+     * {@link https://en.wikipedia.org/wiki/Cross_product}
+     */
+    function cross(v, u) {
+        const [vx, vy, vz] = v;
+        const [ux, uy, uz] = u;
+        return [vy * uz - vz * uy, vz * ux - vx * uz, vx * uy - vy * ux];
+    }
+    Vector.cross = cross;
+    /**
+     * Compute the norm of a vector.
+     *
+     * {@link https://en.wikipedia.org/wiki/Norm_(mathematics)}
+     */
+    function norm(v) {
+        return sqrt(v.reduce((s, n) => s + n ** 2, 0));
+    }
+    Vector.norm = norm;
+    /**
+     * Compute a unit vector corresponding to a vector.
+     *
+     * {@link https://en.wikipedia.org/wiki/Unit_vector}
+     */
+    function normalize(v) {
+        return divide(v, norm(v));
+    }
+    Vector.normalize = normalize;
+})(Vector || (Vector = {}));
+//# sourceMappingURL=vector.js.map

package/package.json

@@ -0,0 +1,31 @@
+{
+  "$schema": "http://json.schemastore.org/package",
+  "name": "@siteimprove/alfa-math",
+  "homepage": "https://alfa.siteimprove.com",
+  "version": "0.89.5",
+  "license": "MIT",
+  "description": "Functionality for working with numbers and mathematical structures, such as vectors and matrices",
+  "repository": {
+    "type": "git",
+    "url": "github:Siteimprove/alfa",
+    "directory": "packages/alfa-math"
+  },
+  "bugs": "https://github.com/siteimprove/alfa/issues",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "devDependencies": {
+    "@siteimprove/alfa-test": "^0.89.5"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://npm.pkg.github.com/"
+  }
+}