@lakuna/umath 1.4.3 → 2.0.0

package/src/linalg/Vector4.ts

@@ -249,6 +249,27 @@ export const max = <T extends Vector4Like>(
 		out
 	);
 
+/**
+ * Raise each component of a vector to the given power.
+ * @param vector - The base.
+ * @param scalar - The exponent (power) to raise each component to.
+ * @param out - The vector to store the result in.
+ * @returns The power (result of the exponentiation).
+ * @public
+ */
+export const pow = <T extends Vector4Like>(
+	vector: Vector4Like,
+	scalar: number,
+	out: T
+): T =>
+	fromValues(
+		vector[0] ** scalar,
+		vector[1] ** scalar,
+		vector[2] ** scalar,
+		vector[3] ** scalar,
+		out
+	);
+
 /**
  * Scale a vector by a scalar.
  * @param vector - The multiplier.
@@ -301,13 +322,8 @@ export const scaleAndAdd = <T extends Vector4Like>(
  * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
  * @public
  */
-export const distance = (a: Vector4Like, b: Vector4Like): number => {
-	const x = a[0] - b[0];
-	const y = a[1] - b[1];
-	const z = a[2] - b[2];
-	const w = a[3] - b[3];
-	return Math.sqrt(x * x + y * y + z * z + w * w); // `Math.hypot` is slower.
-};
+export const distance = (a: Vector4Like, b: Vector4Like): number =>
+	Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2], a[3] - b[3]);
 
 /**
  * Calculate the squared Euclidean distance between two vectors.
@@ -331,13 +347,8 @@ export const squaredDistance = (a: Vector4Like, b: Vector4Like): number => {
  * @returns The magnitude.
  * @public
  */
-export const getMagnitude = (vector: Vector4Like): number => {
-	const x = vector[0];
-	const y = vector[1];
-	const z = vector[2];
-	const w = vector[3];
-	return Math.sqrt(x * x + y * y + z * z + w * w); // `Math.hypot` is slower.
-};
+export const getMagnitude = (vector: Vector4Like): number =>
+	Math.hypot(vector[0], vector[1], vector[2], vector[3]);
 
 /**
  * Calculate the squared magnitude (length) of a vector.
@@ -603,17 +614,15 @@ export default class Vector4
 	 * @param y - The second component.
 	 * @param z - The third component.
 	 * @param w - The fourth component.
-	 * @param out - The vector to store the result in.
 	 * @returns A new vector.
 	 */
-	public static fromValues<T extends Vector4Like = Vector4>(
+	public static fromValues(
 		x: number,
 		y: number,
 		z: number,
-		w: number,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return fromValues(x, y, z, w, out);
+		w: number
+	): Vector4 {
+		return fromValues(x, y, z, w, new Vector4());
 	}
 
 	/**
@@ -657,25 +666,18 @@ export default class Vector4
 	/**
 	 * Add two vectors of the same size.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The sum of the vectors.
 	 */
-	public add<T extends Vector4Like = Vector4>(
-		vector: Vector4Like,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return add(this, vector, out);
+	public add(vector: Vector4Like): Vector4 {
+		return add(this, vector, new Vector4());
 	}
 
 	/**
 	 * Copy the values from this vector to another one.
-	 * @param out - The vector to store the result in.
 	 * @returns The copy.
 	 */
-	public clone<T extends Vector4Like = Vector4>(
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return copy(this, out);
+	public clone(): Vector4 {
+		return copy(this, new Vector4());
 	}
 
 	/**
@@ -690,138 +692,106 @@ export default class Vector4
 	/**
 	 * Multiply this vector by another.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The product of the vectors.
 	 */
-	public multiply<T extends Vector4Like = Vector4>(
-		vector: Vector4Like,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return multiply(this, vector, out);
+	public multiply(vector: Vector4Like): Vector4 {
+		return multiply(this, vector, new Vector4());
 	}
 
 	/**
 	 * Divide this vector by another.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The quotient of the vectors.
 	 */
-	public divide<T extends Vector4Like = Vector4>(
-		vector: Vector4Like,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return divide(this, vector, out);
+	public divide(vector: Vector4Like): Vector4 {
+		return divide(this, vector, new Vector4());
 	}
 
 	/**
 	 * Subtract another vector from this one.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The difference between the vectors.
 	 */
-	public subtract<T extends Vector4Like = Vector4>(
-		vector: Vector4Like,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return subtract(this, vector, out);
+	public subtract(vector: Vector4Like): Vector4 {
+		return subtract(this, vector, new Vector4());
 	}
 
 	/**
 	 * Absolutize the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The absolutized vector.
 	 */
-	public abs<T extends Vector4Like = Vector4>(
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return abs(this, out);
+	public abs(): Vector4 {
+		return abs(this, new Vector4());
 	}
 
 	/**
 	 * Round up the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The rounded vector.
 	 */
-	public ceil<T extends Vector4Like = Vector4>(
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return ceil(this, out);
+	public ceil(): Vector4 {
+		return ceil(this, new Vector4());
 	}
 
 	/**
 	 * Round down the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The rounded vector.
 	 */
-	public floor<T extends Vector4Like = Vector4>(
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return floor(this, out);
+	public floor(): Vector4 {
+		return floor(this, new Vector4());
 	}
 
 	/**
 	 * Round the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The rounded vector.
 	 */
-	public round<T extends Vector4Like = Vector4>(
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return round(this, out);
+	public round(): Vector4 {
+		return round(this, new Vector4());
 	}
 
 	/**
 	 * Return the minimum of this and another vector.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The minimum.
 	 */
-	public min<T extends Vector4Like = Vector4>(
-		vector: Vector4Like,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return min(this, vector, out);
+	public min(vector: Vector4Like): Vector4 {
+		return min(this, vector, new Vector4());
 	}
 
 	/**
 	 * Return the maximum of this and another vector.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The maximum.
 	 */
-	public max<T extends Vector4Like = Vector4>(
-		vector: Vector4Like,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return max(this, vector, out);
+	public max(vector: Vector4Like): Vector4 {
+		return max(this, vector, new Vector4());
+	}
+
+	/**
+	 * Raise each component of this vector to the given power.
+	 * @param scalar - The exponent (power) to raise each component to.
+	 * @returns The power (result of the exponentiation).
+	 */
+	public pow(scalar: number): Vector4 {
+		return pow(this, scalar, new Vector4());
 	}
 
 	/**
 	 * Scale this vector by a scalar.
 	 * @param scalar - The scalar.
-	 * @param out - The vector to store the result in.
 	 * @returns The scaled vector.
 	 */
-	public scale<T extends Vector4Like = Vector4>(
-		scalar: number,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return scale(this, scalar, out);
+	public scale(scalar: number): Vector4 {
+		return scale(this, scalar, new Vector4());
 	}
 
 	/**
 	 * Add another vector to this one after scaling the other by a scalar.
 	 * @param vector - The other vector.
 	 * @param scalar - The scalar.
-	 * @param out - The vector to store the result in.
 	 * @returns The sum.
 	 */
-	public scaleAndAdd<T extends Vector4Like = Vector4>(
-		vector: Vector4Like,
-		scalar: number,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return scaleAndAdd(this, vector, scalar, out);
+	public scaleAndAdd(vector: Vector4Like, scalar: number): Vector4 {
+		return scaleAndAdd(this, vector, scalar, new Vector4());
 	}
 
 	/**
@@ -844,48 +814,47 @@ export default class Vector4
 		return squaredDistance(this, vector);
 	}
 
-	/** Get the magnitude (length) of this vector. */
+	/** The magnitude (length) of this vector. */
 	public get magnitude(): number {
 		return getMagnitude(this);
 	}
 
-	/** Get the squared magnitude (length) of this vector. */
+	public set magnitude(value: number) {
+		scale(normalize(this, this), value, this);
+	}
+
+	/** The squared magnitude (length) of this vector. */
 	public get squaredMagnitude(): number {
 		return getSquaredMagnitude(this);
 	}
 
+	public set squaredMagnitude(value: number) {
+		this.magnitude = Math.sqrt(value);
+	}
+
 	/**
 	 * Negate this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The negated vector.
 	 */
-	public negate<T extends Vector4Like = Vector4>(
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return negate(this, out);
+	public negate(): Vector4 {
+		return negate(this, new Vector4());
 	}
 
 	/**
 	 * Calculate the multiplicative inverse of the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The inverted vector.
 	 */
-	public invert<T extends Vector4Like = Vector4>(
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return invert(this, out);
+	public invert(): Vector4 {
+		return invert(this, new Vector4());
 	}
 
 	/**
 	 * Normalize this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The normalized vector.
 	 * @see {@link https://en.wikipedia.org/wiki/Unit_vector | Unit vector}
 	 */
-	public normalize<T extends Vector4Like = Vector4>(
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return normalize(this, out);
+	public normalize(): Vector4 {
+		return normalize(this, new Vector4());
 	}
 
 	/**
@@ -902,32 +871,22 @@ export default class Vector4
 	 * Calculate the cross product of this and two other vectors in a four-dimensional space.
 	 * @param a - One other vector.
 	 * @param b - The other other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The cross product.
 	 * @see {@link https://en.wikipedia.org/wiki/Cross_product | Cross product}
 	 */
-	public cross<T extends Vector4Like = Vector4>(
-		a: Vector4Like,
-		b: Vector4Like,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return cross(this, a, b, out);
+	public cross(a: Vector4Like, b: Vector4Like): Vector4 {
+		return cross(this, a, b, new Vector4());
 	}
 
 	/**
 	 * Perform a linear interpolation between this and another vector.
 	 * @param vector - The other vector.
 	 * @param t - The interpolation amount (in `[0,1]`).
-	 * @param out - The vector to store the result in.
 	 * @returns The interpolated vector.
 	 * @see {@link https://en.wikipedia.org/wiki/Linear_interpolation | Linear interpolation}
 	 */
-	public lerp<T extends Vector4Like = Vector4>(
-		vector: Vector4Like,
-		t: number,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return lerp(this, vector, t, out);
+	public lerp(vector: Vector4Like, t: number): Vector4 {
+		return lerp(this, vector, t, new Vector4());
 	}
 
 	/**
@@ -942,15 +901,11 @@ export default class Vector4
 	/**
 	 * Transform this vector by a four-by-four matrix.
 	 * @param matrix - The matrix.
-	 * @param out - The vector to store the result in.
 	 * @returns The transformed vector.
 	 * @see {@link https://en.wikipedia.org/wiki/Transformation_matrix | Transformation matrix}
 	 */
-	public transformMatrix4<T extends Vector4Like = Vector4>(
-		matrix: Matrix4Like,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return transformMatrix4(this, matrix, out);
+	public transformMatrix4(matrix: Matrix4Like): Vector4 {
+		return transformMatrix4(this, matrix, new Vector4());
 	}
 
 	/**
@@ -964,14 +919,10 @@ export default class Vector4
 	/**
 	 * Transform this vector by a quaternion.
 	 * @param quaternion - The quaternion.
-	 * @param out - The vector to store the result in.
 	 * @returns The transformed vector.
 	 * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
 	 */
-	public transformQuaternion<T extends Vector4Like = Vector4>(
-		quaternion: QuaternionLike,
-		out: T = new Vector4() as Vector4 & T
-	): T {
-		return transformQuaternion(this, quaternion, out);
+	public transformQuaternion(quaternion: QuaternionLike): Vector4 {
+		return transformQuaternion(this, quaternion, new Vector4());
 	}
 }

package/src/utility/MatrixSizeError.ts

@@ -2,7 +2,7 @@
  * An error resulting from trying to use a matrix that is the wrong size.
  * @public
  */
-export default class PartialMatrixError extends Error {
+export default class MatrixSizeError extends Error {
 	/**
 	 * Create an error resulting from trying to use a matrix that is the wrong size.
 	 * @param message - The message of the error.

package/src/utility/VectorSizeError.ts

@@ -0,0 +1,14 @@
+/**
+ * An error resulting from trying to use a vector that is the wrong size.
+ * @public
+ */
+export default class VectorSizeError extends Error {
+	/**
+	 * Create an error resulting from trying to use a vector that is the wrong size.
+	 * @param message - The message of the error.
+	 */
+	public constructor(message = "Invalid vector dimensions.") {
+		super(message);
+		this.name = "VectorSizeError";
+	}
+}

package/src/utility/createAxisAngleLike.ts

@@ -0,0 +1,13 @@
+import type AxisAngle from "../types/AxisAngle.js";
+import { createVector3Like } from "../linalg/Vector3.js";
+
+/**
+ * Create an empty axis-angle pair.
+ * @returns An empty axis-angle pair.
+ * @public
+ */
+export default function createAxisAngleLike(): AxisAngle & {
+	axis: Float32Array;
+} {
+	return { angle: 0, axis: createVector3Like() };
+}