@lakuna/umath 2.0.0 → 3.0.0

package/src/linalg/SlowSquareMatrix.ts

@@ -1,7 +1,8 @@
+import type SquareMatrix from "./SquareMatrix.js";
+
 import MatrixSizeError from "../utility/MatrixSizeError.js";
 import SingularMatrixError from "../utility/SingularMatrixError.js";
 import SlowMatrix from "./SlowMatrix.js";
-import type SquareMatrix from "./SquareMatrix.js";
 
 /**
  * A variable-size matrix with the same number of rows and columns.
@@ -12,23 +13,6 @@ export default class SlowSquareMatrix
 	extends SlowMatrix
 	implements SquareMatrix
 {
-	/**
-	 * Create a variable-size matrix with the same number of rows and columns from the given columns.
-	 * @param cols - The columns in the matrix.
-	 * @see {@link https://en.wikipedia.org/wiki/Square_matrix | Square matrix}
-	 */
-	public constructor(...cols: number[][]) {
-		super(...cols);
-
-		// Ensure that every column is the same height and that the height is equal to the width.
-		for (let i = 0; i < this.width; i++) {
-			const col = cols[i];
-			if (col?.length !== this.height) {
-				throw new MatrixSizeError();
-			}
-		}
-	}
-
 	/**
 	 * Get the determinant of this matrix.
 	 * @see {@link https://en.wikipedia.org/wiki/Determinant | Determinant}
@@ -54,6 +38,23 @@ export default class SlowSquareMatrix
 		return out;
 	}
 
+	/**
+	 * Create a variable-size matrix with the same number of rows and columns from the given columns.
+	 * @param cols - The columns in the matrix.
+	 * @see {@link https://en.wikipedia.org/wiki/Square_matrix | Square matrix}
+	 */
+	public constructor(...cols: number[][]) {
+		super(...cols);
+
+		// Ensure that every column is the same height and that the height is equal to the width.
+		for (let i = 0; i < this.width; i++) {
+			const col = cols[i];
+			if (col?.length !== this.height) {
+				throw new MatrixSizeError();
+			}
+		}
+	}
+
 	/**
 	 * Calculate the adjugate of this matrix.
 	 * @returns The adjugate of this matrix.

package/src/linalg/SlowVector.ts

@@ -1,7 +1,8 @@
 import type Vector from "./Vector.js";
 import type { VectorLike } from "./Vector.js";
-import VectorSizeError from "../utility/VectorSizeError.js";
+
 import approx from "../algorithms/approx.js";
+import VectorSizeError from "../utility/VectorSizeError.js";
 
 /**
  * A vector with size information.
@@ -25,56 +26,27 @@ const isSized = (vector: VectorLike): vector is SizedVectorLike =>
  * @public
  */
 export default class SlowVector extends Float32Array implements Vector {
-	/**
-	 * Create a variable-size vector from the given values.
-	 * @param values - The values in the vector.
-	 */
-	public constructor(...values: number[]) {
-		super(values);
+	/** Get the magnitude (length) of this vector. */
+	public get magnitude(): number {
+		return Math.hypot(...this);
 	}
 
-	/**
-	 * Determine whether this vector is roughly equivalent to another.
-	 * @param vector - The other vector.
-	 * @returns Whether the vectors are equivalent.
-	 */
-	public equals(vector: VectorLike): boolean {
-		if (!isSized(vector) || this.length !== vector.length) {
-			throw new VectorSizeError();
-		}
-
+	/** Get the squared magnitude (length) of this vector. */
+	public get squaredMagnitude(): number {
+		let out = 0;
 		for (let i = 0; i < this.length; i++) {
-			const a = this[i];
-			const b = vector[i];
-			if (
-				typeof a === "undefined" ||
-				typeof b === "undefined" ||
-				!approx(a, b)
-			) {
-				return false;
-			}
+			out += (this[i] ?? 0) ** 2;
 		}
 
-		return true;
+		return out;
 	}
 
 	/**
-	 * Determine whether this vector is exactly equivalent to another.
-	 * @param vector - The other vector.
-	 * @returns Whether the vectors are equivalent.
+	 * Create a variable-size vector from the given values.
+	 * @param values - The values in the vector.
 	 */
-	public exactEquals(vector: VectorLike): boolean {
-		if (!isSized(vector) || this.length !== vector.length) {
-			throw new VectorSizeError();
-		}
-
-		for (let i = 0; i < this.length; i++) {
-			if (this[i] !== vector[i]) {
-				return false;
-			}
-		}
-
-		return true;
+	public constructor(...values: number[]) {
+		super(values);
 	}
 
 	/**
@@ -95,6 +67,19 @@ export default class SlowVector extends Float32Array implements Vector {
 		return new SlowVector(...out);
 	}
 
+	/**
+	 * Round up the components of this vector.
+	 * @returns The rounded vector.
+	 */
+	public ceil(): SlowVector {
+		const out = [];
+		for (let i = 0; i < this.length; i++) {
+			out[i] = Math.ceil(this[i] ?? 0);
+		}
+
+		return new SlowVector(...out);
+	}
+
 	/**
 	 * Create a copy of this vector.
 	 * @returns A copy of this vector.
@@ -121,21 +106,21 @@ export default class SlowVector extends Float32Array implements Vector {
 	}
 
 	/**
-	 * Multiply this vector by another.
+	 * Calculate the Euclidean distance between this vector and another.
 	 * @param vector - The other vector.
-	 * @returns The product of the vectors.
+	 * @returns The distance.
 	 */
-	public multiply(vector: VectorLike): SlowVector {
+	public distance(vector: VectorLike): number {
 		if (!isSized(vector) || this.length !== vector.length) {
 			throw new VectorSizeError();
 		}
 
-		const out = [];
+		const temp = [];
 		for (let i = 0; i < this.length; i++) {
-			out[i] = (this[i] ?? 0) * (vector[i] ?? 0);
+			temp[i] = (vector[i] ?? 0) - (this[i] ?? 0);
 		}
 
-		return new SlowVector(...out);
+		return Math.hypot(...temp);
 	}
 
 	/**
@@ -157,34 +142,66 @@ export default class SlowVector extends Float32Array implements Vector {
 	}
 
 	/**
-	 * Subtract another vector from this one.
+	 * Calculate the dot product of this and another vector.
 	 * @param vector - The other vector.
-	 * @returns The difference between the vectors.
+	 * @returns The dot product.
+	 * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
 	 */
-	public subtract(vector: VectorLike): SlowVector {
+	public dot(vector: VectorLike): number {
 		if (!isSized(vector) || this.length !== vector.length) {
 			throw new VectorSizeError();
 		}
 
-		const out = [];
+		let out = 0;
 		for (let i = 0; i < this.length; i++) {
-			out[i] = (this[i] ?? 0) - (vector[i] ?? 0);
+			out += (this[i] ?? 0) * (vector[i] ?? 0);
 		}
 
-		return new SlowVector(...out);
+		return out;
 	}
 
 	/**
-	 * Round up the components of this vector.
-	 * @returns The rounded vector.
+	 * Determine whether this vector is roughly equivalent to another.
+	 * @param vector - The other vector.
+	 * @returns Whether the vectors are equivalent.
 	 */
-	public ceil(): SlowVector {
-		const out = [];
+	public equals(vector: VectorLike): boolean {
+		if (!isSized(vector) || this.length !== vector.length) {
+			throw new VectorSizeError();
+		}
+
 		for (let i = 0; i < this.length; i++) {
-			out[i] = Math.ceil(this[i] ?? 0);
+			const a = this[i];
+			const b = vector[i];
+			if (
+				typeof a === "undefined" ||
+				typeof b === "undefined" ||
+				!approx(a, b)
+			) {
+				return false;
+			}
 		}
 
-		return new SlowVector(...out);
+		return true;
+	}
+
+	/**
+	 * Determine whether this vector is exactly equivalent to another.
+	 * @param vector - The other vector.
+	 * @returns Whether the vectors are equivalent.
+	 */
+	public exactEquals(vector: VectorLike): boolean {
+		if (!isSized(vector) || this.length !== vector.length) {
+			throw new VectorSizeError();
+		}
+
+		for (let i = 0; i < this.length; i++) {
+			if (this[i] !== vector[i]) {
+				return false;
+			}
+		}
+
+		return true;
 	}
 
 	/**
@@ -201,31 +218,33 @@ export default class SlowVector extends Float32Array implements Vector {
 	}
 
 	/**
-	 * Round the components of this vector.
-	 * @returns The rounded vector.
+	 * Calculate the multiplicative inverse of the components of this vector.
+	 * @returns The inverted vector.
 	 */
-	public round(): SlowVector {
+	public invert(): SlowVector {
 		const out = [];
 		for (let i = 0; i < this.length; i++) {
-			out[i] = Math.round(this[i] ?? 0);
+			out[i] = 1 / (this[i] ?? 0);
 		}
 
 		return new SlowVector(...out);
 	}
 
 	/**
-	 * Return the minimum of this and another vector.
+	 * Perform a linear interpolation between this and another vector.
 	 * @param vector - The other vector.
-	 * @returns The minimum.
+	 * @param t - The interpolation amount (in `[0,1]`).
+	 * @returns The interpolated vector.
 	 */
-	public min(vector: VectorLike): SlowVector {
+	public lerp(vector: VectorLike, t: number): SlowVector {
 		if (!isSized(vector) || this.length !== vector.length) {
 			throw new VectorSizeError();
 		}
 
 		const out = [];
 		for (let i = 0; i < this.length; i++) {
-			out[i] = Math.min(this[i] ?? 0, vector[i] ?? 0);
+			const ti = this[i] ?? 0;
+			out[i] = ti + t * ((vector[i] ?? 0) - ti);
 		}
 
 		return new SlowVector(...out);
@@ -250,191 +269,173 @@ export default class SlowVector extends Float32Array implements Vector {
 	}
 
 	/**
-	 * Raise each component of this vector to the given power.
-	 * @param exponent - The exponent (power) to raise each component to.
-	 * @returns The power (result of the exponentiation).
+	 * Return the minimum of this and another vector.
+	 * @param vector - The other vector.
+	 * @returns The minimum.
 	 */
-	public pow(exponent: number): SlowVector {
-		const out = [];
-		for (let i = 0; i < this.length; i++) {
-			out[i] = (this[i] ?? 0) ** exponent;
+	public min(vector: VectorLike): SlowVector {
+		if (!isSized(vector) || this.length !== vector.length) {
+			throw new VectorSizeError();
 		}
 
-		return new SlowVector(...out);
-	}
-
-	/**
-	 * Scale this vector by a scalar.
-	 * @param scalar - The scalar.
-	 * @returns The scaled vector.
-	 */
-	public scale(scalar: number): SlowVector {
 		const out = [];
 		for (let i = 0; i < this.length; i++) {
-			out[i] = (this[i] ?? 0) * scalar;
+			out[i] = Math.min(this[i] ?? 0, vector[i] ?? 0);
 		}
 
 		return new SlowVector(...out);
 	}
 
 	/**
-	 * Add another vector to this one after scaling the other by a scalar.
+	 * Multiply this vector by another.
 	 * @param vector - The other vector.
-	 * @param scalar - The scalar.
-	 * @returns The sum.
+	 * @returns The product of the vectors.
 	 */
-	public scaleAndAdd(vector: VectorLike, scalar: number): SlowVector {
-		if (!isSized(vector)) {
+	public multiply(vector: VectorLike): SlowVector {
+		if (!isSized(vector) || this.length !== vector.length) {
 			throw new VectorSizeError();
 		}
 
 		const out = [];
-		for (let i = 0; i < vector.length; i++) {
-			out[i] = (vector[i] ?? 0) * scalar;
+		for (let i = 0; i < this.length; i++) {
+			out[i] = (this[i] ?? 0) * (vector[i] ?? 0);
 		}
 
-		return this.add(out);
+		return new SlowVector(...out);
 	}
 
 	/**
-	 * Calculate the Euclidean distance between this vector and another.
-	 * @param vector - The other vector.
-	 * @returns The distance.
+	 * Negate this vector.
+	 * @returns The negated vector.
 	 */
-	public distance(vector: VectorLike): number {
-		if (!isSized(vector) || this.length !== vector.length) {
-			throw new VectorSizeError();
-		}
-
-		const temp = [];
-		for (let i = 0; i < this.length; i++) {
-			temp[i] = (vector[i] ?? 0) - (this[i] ?? 0);
-		}
-
-		return Math.hypot(...temp);
+	public negate(): SlowVector {
+		return this.scale(-1);
 	}
 
 	/**
-	 * Calculate the squared Euclidean distance between this vector and another.
-	 * @param vector - The other vector.
-	 * @returns The squared distance.
+	 * Normalize this vector.
+	 * @returns The normalized vector.
+	 * @see {@link https://en.wikipedia.org/wiki/Unit_vector | Unit vector}
 	 */
-	public squaredDistance(vector: VectorLike): number {
-		if (!isSized(vector) || this.length !== vector.length) {
-			throw new VectorSizeError();
-		}
+	public normalize(): SlowVector {
+		return this.scale(1 / this.magnitude);
+	}
 
-		let out = 0;
+	/**
+	 * Raise each component of this vector to the given power.
+	 * @param exponent - The exponent (power) to raise each component to.
+	 * @returns The power (result of the exponentiation).
+	 */
+	public pow(exponent: number): SlowVector {
+		const out = [];
 		for (let i = 0; i < this.length; i++) {
-			out += ((vector[i] ?? 0) - (this[i] ?? 0)) ** 2;
+			out[i] = (this[i] ?? 0) ** exponent;
 		}
 
-		return out;
+		return new SlowVector(...out);
 	}
 
-	/** Get the magnitude (length) of this vector. */
-	public get magnitude(): number {
-		return Math.hypot(...this);
-	}
+	/**
+	 * Set this vector to a random value with the given magnitude.
+	 * @param magnitude - The magnitude.
+	 * @returns This vector.
+	 */
+	public random(magnitude: number): this {
+		const temp = [];
+		for (let i = 0; i < this.length; i++) {
+			temp[i] = Math.random();
+		}
 
-	/** Get the squared magnitude (length) of this vector. */
-	public get squaredMagnitude(): number {
-		let out = 0;
+		const randomized = new SlowVector(...temp).normalize().scale(magnitude);
 		for (let i = 0; i < this.length; i++) {
-			out += (this[i] ?? 0) ** 2;
+			this[i] = randomized[i] ?? 0;
 		}
 
-		return out;
+		return this;
 	}
 
 	/**
-	 * Negate this vector.
-	 * @returns The negated vector.
+	 * Round the components of this vector.
+	 * @returns The rounded vector.
 	 */
-	public negate(): SlowVector {
-		return this.scale(-1);
+	public round(): SlowVector {
+		const out = [];
+		for (let i = 0; i < this.length; i++) {
+			out[i] = Math.round(this[i] ?? 0);
+		}
+
+		return new SlowVector(...out);
 	}
 
 	/**
-	 * Calculate the multiplicative inverse of the components of this vector.
-	 * @returns The inverted vector.
+	 * Scale this vector by a scalar.
+	 * @param scalar - The scalar.
+	 * @returns The scaled vector.
 	 */
-	public invert(): SlowVector {
+	public scale(scalar: number): SlowVector {
 		const out = [];
 		for (let i = 0; i < this.length; i++) {
-			out[i] = 1 / (this[i] ?? 0);
+			out[i] = (this[i] ?? 0) * scalar;
 		}
 
 		return new SlowVector(...out);
 	}
 
 	/**
-	 * Normalize this vector.
-	 * @returns The normalized vector.
-	 * @see {@link https://en.wikipedia.org/wiki/Unit_vector | Unit vector}
+	 * Add another vector to this one after scaling the other by a scalar.
+	 * @param vector - The other vector.
+	 * @param scalar - The scalar.
+	 * @returns The sum.
 	 */
-	public normalize(): SlowVector {
-		return this.scale(1 / this.magnitude);
+	public scaleAndAdd(vector: VectorLike, scalar: number): SlowVector {
+		if (!isSized(vector)) {
+			throw new VectorSizeError();
+		}
+
+		const out = [];
+		for (let i = 0; i < vector.length; i++) {
+			out[i] = (vector[i] ?? 0) * scalar;
+		}
+
+		return this.add(out);
 	}
 
 	/**
-	 * Calculate the dot product of this and another vector.
+	 * Calculate the squared Euclidean distance between this vector and another.
 	 * @param vector - The other vector.
-	 * @returns The dot product.
-	 * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
+	 * @returns The squared distance.
 	 */
-	public dot(vector: VectorLike): number {
+	public squaredDistance(vector: VectorLike): number {
 		if (!isSized(vector) || this.length !== vector.length) {
 			throw new VectorSizeError();
 		}
 
 		let out = 0;
 		for (let i = 0; i < this.length; i++) {
-			out += (this[i] ?? 0) * (vector[i] ?? 0);
+			out += ((vector[i] ?? 0) - (this[i] ?? 0)) ** 2;
 		}
 
 		return out;
 	}
 
 	/**
-	 * Perform a linear interpolation between this and another vector.
+	 * Subtract another vector from this one.
 	 * @param vector - The other vector.
-	 * @param t - The interpolation amount (in `[0,1]`).
-	 * @returns The interpolated vector.
+	 * @returns The difference between the vectors.
 	 */
-	public lerp(vector: VectorLike, t: number): SlowVector {
+	public subtract(vector: VectorLike): SlowVector {
 		if (!isSized(vector) || this.length !== vector.length) {
 			throw new VectorSizeError();
 		}
 
 		const out = [];
 		for (let i = 0; i < this.length; i++) {
-			const ti = this[i] ?? 0;
-			out[i] = ti + t * ((vector[i] ?? 0) - ti);
+			out[i] = (this[i] ?? 0) - (vector[i] ?? 0);
 		}
 
 		return new SlowVector(...out);
 	}
 
-	/**
-	 * Set this vector to a random value with the given magnitude.
-	 * @param magnitude - The magnitude.
-	 * @returns This vector.
-	 */
-	public random(magnitude: number): this {
-		const temp = [];
-		for (let i = 0; i < this.length; i++) {
-			temp[i] = Math.random();
-		}
-
-		const randomized = new SlowVector(...temp).normalize().scale(magnitude);
-		for (let i = 0; i < this.length; i++) {
-			this[i] = randomized[i] ?? 0;
-		}
-
-		return this;
-	}
-
 	/**
 	 * Set this to the zero vector.
 	 * @returns This vector.

package/src/linalg/SquareMatrix.ts

@@ -6,30 +6,30 @@ import type { default as Matrix, MatrixLike } from "./Matrix.js";
  * @public
  */
 export default interface SquareMatrix extends Matrix {
-	/**
-	 * Get the determinant of this matrix.
-	 * @see {@link https://en.wikipedia.org/wiki/Determinant | Determinant}
-	 */
-	get determinant(): number;
-
 	/**
 	 * Calculate the adjugate of this matrix.
 	 * @returns The adjugate of this matrix.
 	 * @see {@link https://en.wikipedia.org/wiki/Adjugate_matrix | Adjugate matrix}
 	 */
-	adjoint(): MatrixLike;
+	adjoint: () => MatrixLike;
+
+	/**
+	 * Get the determinant of this matrix.
+	 * @see {@link https://en.wikipedia.org/wiki/Determinant | Determinant}
+	 */
+	get determinant(): number;
 
 	/**
 	 * Reset this matrix to identity.
 	 * @returns This matrix.
 	 * @see {@link https://en.wikipedia.org/wiki/Identity_matrix | Identity matrix}
 	 */
-	identity(): this;
+	identity: () => this;
 
 	/**
 	 * Invert this matrix.
 	 * @returns The inverted matrix.
 	 * @see {@link https://en.wikipedia.org/wiki/Invertible_matrix | Invertible matrix}
 	 */
-	invert(): MatrixLike;
+	invert: () => MatrixLike;
 }