@lakuna/umath 2.0.0 → 3.0.1

package/src/linalg/Vector2.ts

@@ -1,12 +1,13 @@
-import type { default as Vector, VectorLike } from "./Vector.js";
-import Vector3, {
-	type Vector3Like,
-	fromValues as vector3FromValues
-} from "./Vector3.js";
 import type { Matrix2Like } from "./Matrix2.js";
 import type { Matrix3Like } from "./Matrix3.js";
 import type { Matrix4Like } from "./Matrix4.js";
+import type { default as Vector, VectorLike } from "./Vector.js";
+
 import approxRelative from "../algorithms/approxRelative.js";
+import Vector3, {
+	fromValues as vector3FromValues,
+	type Vector3Like
+} from "./Vector3.js";
 
 /**
  * A quantity with magnitude and direction in two dimensions.
@@ -14,9 +15,11 @@ import approxRelative from "../algorithms/approxRelative.js";
  */
 export interface Vector2Like extends VectorLike {
 	/** The first component of this vector. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	0: number;
 
 	/** The second component of this vector. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	1: number;
 }
 
@@ -25,9 +28,9 @@ export interface Vector2Like extends VectorLike {
  * @returns A 2x1 vector-like object.
  * @public
  */
-export const createVector2Like = (): Float32Array & Vector2Like => {
-	return new Float32Array(2) as Float32Array & Vector2Like;
-};
+export const createVector2Like = (): Float32Array & Vector2Like =>
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+	new Float32Array(2) as Float32Array & Vector2Like;
 
 /**
  * Create a vector with the given values.
@@ -54,8 +57,10 @@ export const fromValues = <T extends Vector2Like>(
  * @returns Whether or not the vectors are equivalent.
  * @public
  */
-export const equals = (a: Vector2Like, b: Vector2Like): boolean =>
-	approxRelative(a[0], b[0]) && approxRelative(a[1], b[1]);
+export const equals = (
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>
+): boolean => approxRelative(a[0], b[0]) && approxRelative(a[1], b[1]);
 
 /**
  * Determine whether or not two vectors are exactly equivalent.
@@ -64,8 +69,10 @@ export const equals = (a: Vector2Like, b: Vector2Like): boolean =>
  * @returns Whether or not the vectors are equivalent.
  * @public
  */
-export const exactEquals = (a: Vector2Like, b: Vector2Like): boolean =>
-	a[0] === b[0] && a[1] === b[1];
+export const exactEquals = (
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>
+): boolean => a[0] === b[0] && a[1] === b[1];
 
 /**
  * Add two vectors.
@@ -75,9 +82,9 @@ export const exactEquals = (a: Vector2Like, b: Vector2Like): boolean =>
  * @returns The sum.
  * @public
  */
-export const add = <T extends Vector2Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+export const add = <T extends Readonly<Vector2Like>>(
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	out: T
 ): T => fromValues(a[0] + b[0], a[1] + b[1], out);
 
@@ -88,8 +95,10 @@ export const add = <T extends Vector2Like>(
  * @returns The copy.
  * @public
  */
-export const copy = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
-	fromValues(vector[0], vector[1], out);
+export const copy = <T extends Vector2Like>(
+	vector: Readonly<Vector2Like>,
+	out: T
+): T => fromValues(vector[0], vector[1], out);
 
 /**
  * Multiply the components in one vector by the corresponding components in another.
@@ -100,8 +109,8 @@ export const copy = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
  * @public
  */
 export const multiply = <T extends Vector2Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	out: T
 ): T => fromValues(a[0] * b[0], a[1] * b[1], out);
 
@@ -114,8 +123,8 @@ export const multiply = <T extends Vector2Like>(
  * @public
  */
 export const divide = <T extends Vector2Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	out: T
 ): T => fromValues(a[0] / b[0], a[1] / b[1], out);
 
@@ -128,8 +137,8 @@ export const divide = <T extends Vector2Like>(
  * @public
  */
 export const subtract = <T extends Vector2Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	out: T
 ): T => fromValues(a[0] - b[0], a[1] - b[1], out);
 
@@ -140,8 +149,10 @@ export const subtract = <T extends Vector2Like>(
  * @returns The absolutized vector.
  * @public
  */
-export const abs = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
-	fromValues(Math.abs(vector[0]), Math.abs(vector[1]), out);
+export const abs = <T extends Vector2Like>(
+	vector: Readonly<Vector2Like>,
+	out: T
+): T => fromValues(Math.abs(vector[0]), Math.abs(vector[1]), out);
 
 /**
  * Round up the components of a vector.
@@ -150,8 +161,10 @@ export const abs = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
  * @returns The rounded vector.
  * @public
  */
-export const ceil = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
-	fromValues(Math.ceil(vector[0]), Math.ceil(vector[1]), out);
+export const ceil = <T extends Vector2Like>(
+	vector: Readonly<Vector2Like>,
+	out: T
+): T => fromValues(Math.ceil(vector[0]), Math.ceil(vector[1]), out);
 
 /**
  * Round down the components of a vector.
@@ -160,8 +173,10 @@ export const ceil = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
  * @returns The rounded vector.
  * @public
  */
-export const floor = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
-	fromValues(Math.floor(vector[0]), Math.floor(vector[1]), out);
+export const floor = <T extends Vector2Like>(
+	vector: Readonly<Vector2Like>,
+	out: T
+): T => fromValues(Math.floor(vector[0]), Math.floor(vector[1]), out);
 
 /**
  * Round the components of a vector.
@@ -170,8 +185,10 @@ export const floor = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
  * @returns The rounded vector.
  * @public
  */
-export const round = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
-	fromValues(Math.round(vector[0]), Math.round(vector[1]), out);
+export const round = <T extends Vector2Like>(
+	vector: Readonly<Vector2Like>,
+	out: T
+): T => fromValues(Math.round(vector[0]), Math.round(vector[1]), out);
 
 /**
  * Return the minimum of two vectors.
@@ -182,8 +199,8 @@ export const round = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
  * @public
  */
 export const min = <T extends Vector2Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	out: T
 ): T => fromValues(Math.min(a[0], b[0]), Math.min(a[1], b[1]), out);
 
@@ -196,8 +213,8 @@ export const min = <T extends Vector2Like>(
  * @public
  */
 export const max = <T extends Vector2Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	out: T
 ): T => fromValues(Math.max(a[0], b[0]), Math.max(a[1], b[1]), out);
 
@@ -210,7 +227,7 @@ export const max = <T extends Vector2Like>(
  * @public
  */
 export const pow = <T extends Vector2Like>(
-	vector: Vector2Like,
+	vector: Readonly<Vector2Like>,
 	scalar: number,
 	out: T
 ): T => fromValues(vector[0] ** scalar, vector[1] ** scalar, out);
@@ -224,7 +241,7 @@ export const pow = <T extends Vector2Like>(
  * @public
  */
 export const scale = <T extends Vector2Like>(
-	vector: Vector2Like,
+	vector: Readonly<Vector2Like>,
 	scalar: number,
 	out: T
 ): T => fromValues(vector[0] * scalar, vector[1] * scalar, out);
@@ -239,8 +256,8 @@ export const scale = <T extends Vector2Like>(
  * @public
  */
 export const scaleAndAdd = <T extends Vector2Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	scalar: number,
 	out: T
 ): T => fromValues(a[0] + b[0] * scalar, a[1] + b[1] * scalar, out);
@@ -253,8 +270,10 @@ export const scaleAndAdd = <T extends Vector2Like>(
  * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
  * @public
  */
-export const distance = (a: Vector2Like, b: Vector2Like): number =>
-	Math.hypot(b[0] - a[0], b[1] - a[1]);
+export const distance = (
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>
+): number => Math.hypot(b[0] - a[0], b[1] - a[1]);
 
 /**
  * Calculate the squared Euclidean distance from one vector to another.
@@ -264,7 +283,10 @@ export const distance = (a: Vector2Like, b: Vector2Like): number =>
  * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
  * @public
  */
-export const squaredDistance = (a: Vector2Like, b: Vector2Like): number => {
+export const squaredDistance = (
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>
+): number => {
 	const x = b[0] - a[0];
 	const y = b[1] - a[1];
 	return x * x + y * y;
@@ -276,7 +298,7 @@ export const squaredDistance = (a: Vector2Like, b: Vector2Like): number => {
  * @returns The magnitude.
  * @public
  */
-export const getMagnitude = (vector: Vector2Like): number =>
+export const getMagnitude = (vector: Readonly<Vector2Like>): number =>
 	Math.hypot(vector[0], vector[1]);
 
 /**
@@ -285,7 +307,7 @@ export const getMagnitude = (vector: Vector2Like): number =>
  * @returns The squared magnitude.
  * @public
  */
-export const getSquaredMagnitude = (vector: Vector2Like): number => {
+export const getSquaredMagnitude = (vector: Readonly<Vector2Like>): number => {
 	const x = vector[0];
 	const y = vector[1];
 	return x * x + y * y;
@@ -298,8 +320,10 @@ export const getSquaredMagnitude = (vector: Vector2Like): number => {
  * @returns The negated vector.
  * @public
  */
-export const negate = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
-	fromValues(-vector[0], -vector[1], out);
+export const negate = <T extends Vector2Like>(
+	vector: Readonly<Vector2Like>,
+	out: T
+): T => fromValues(-vector[0], -vector[1], out);
 
 /**
  * Calculate the multiplicative inverse of the components of a vector.
@@ -308,8 +332,10 @@ export const negate = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
  * @returns The inverted vector.
  * @public
  */
-export const invert = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
-	fromValues(1 / vector[0], 1 / vector[1], out);
+export const invert = <T extends Vector2Like>(
+	vector: Readonly<Vector2Like>,
+	out: T
+): T => fromValues(1 / vector[0], 1 / vector[1], out);
 
 /**
  * Normalize a vector.
@@ -320,7 +346,7 @@ export const invert = <T extends Vector2Like>(vector: Vector2Like, out: T): T =>
  * @public
  */
 export const normalize = <T extends Vector2Like>(
-	vector: Vector2Like,
+	vector: Readonly<Vector2Like>,
 	out: T
 ): T => {
 	const x = vector[0];
@@ -342,8 +368,10 @@ export const normalize = <T extends Vector2Like>(
  * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
  * @public
  */
-export const dot = (a: Vector2Like, b: Vector2Like): number =>
-	a[0] * b[0] + a[1] * b[1];
+export const dot = (
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>
+): number => a[0] * b[0] + a[1] * b[1];
 
 /**
  * Calculate the cross product of two vectors.
@@ -355,8 +383,8 @@ export const dot = (a: Vector2Like, b: Vector2Like): number =>
  * @public
  */
 export const cross = <T extends Vector3Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	out: T
 ): T => vector3FromValues(0, 0, a[0] * b[1] - a[1] * b[0], out);
 
@@ -371,8 +399,8 @@ export const cross = <T extends Vector3Like>(
  * @public
  */
 export const lerp = <T extends Vector2Like>(
-	a: Vector2Like,
-	b: Vector2Like,
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>,
 	t: number,
 	out: T
 ): T => {
@@ -405,8 +433,8 @@ export const random = <T extends Vector2Like>(magnitude: number, out: T): T => {
  * @public
  */
 export const transformMatrix2 = <T extends Vector2Like>(
-	vector: Vector2Like,
-	matrix: Matrix2Like,
+	vector: Readonly<Vector2Like>,
+	matrix: Readonly<Matrix2Like>,
 	out: T
 ): T => {
 	const x = vector[0];
@@ -429,8 +457,8 @@ export const transformMatrix2 = <T extends Vector2Like>(
  * @public
  */
 export const transformMatrix3 = <T extends Vector2Like>(
-	vector: Vector2Like,
-	matrix: Matrix3Like,
+	vector: Readonly<Vector2Like>,
+	matrix: Readonly<Matrix3Like>,
 	out: T
 ): T => {
 	const x = vector[0];
@@ -453,8 +481,8 @@ export const transformMatrix3 = <T extends Vector2Like>(
  * @public
  */
 export const transformMatrix4 = <T extends Vector2Like>(
-	vector: Vector2Like,
-	matrix: Matrix4Like,
+	vector: Readonly<Vector2Like>,
+	matrix: Readonly<Matrix4Like>,
 	out: T
 ): T => {
 	const x = vector[0];
@@ -477,8 +505,8 @@ export const transformMatrix4 = <T extends Vector2Like>(
  * @public
  */
 export const rotate = <T extends Vector2Like>(
-	vector: Vector2Like,
-	origin: Vector2Like,
+	vector: Readonly<Vector2Like>,
+	origin: Readonly<Vector2Like>,
 	r: number,
 	out: T
 ): T => {
@@ -501,7 +529,10 @@ export const rotate = <T extends Vector2Like>(
  * @returns The angular distance.
  * @public
  */
-export const angle = (a: Vector2Like, b: Vector2Like): number => {
+export const angle = (
+	a: Readonly<Vector2Like>,
+	b: Readonly<Vector2Like>
+): number => {
 	const x1 = a[0];
 	const y1 = a[1];
 
@@ -529,6 +560,40 @@ export default class Vector2
 	extends Float32Array
 	implements Vector, Vector2Like
 {
+	/** The first component of this vector. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 0: number;
+
+	/** The second component of this vector. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 1: number;
+
+	/** The magnitude (length) of this vector. */
+	public get magnitude(): number {
+		return getMagnitude(this);
+	}
+
+	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);
+	}
+
+	/**
+	 * Create a two-dimensional zero vector.
+	 * @see {@link https://en.wikipedia.org/wiki/Euclidean_vector | Euclidean vector}
+	 */
+	public constructor() {
+		super(2);
+	}
+
 	/**
 	 * Create a vector with the given values.
 	 * @param x - The first component.
@@ -540,44 +605,37 @@ export default class Vector2
 	}
 
 	/**
-	 * Create a two-dimensional zero vector.
-	 * @see {@link https://en.wikipedia.org/wiki/Euclidean_vector | Euclidean vector}
+	 * Absolutize the components of this vector.
+	 * @returns The absolutized vector.
 	 */
-	public constructor() {
-		super(2);
+	public abs(): Vector2 {
+		return abs(this, new Vector2());
 	}
 
-	/** The first component of this vector. */
-	public 0: number;
-
-	/** The second component of this vector. */
-	public 1: number;
-
 	/**
-	 * Determine whether this vector is roughly equivalent to another.
+	 * Add another vector to this one.
 	 * @param vector - The other vector.
-	 * @returns Whether the vectors are equivalent.
+	 * @returns The sum of the vectors.
 	 */
-	public equals(vector: Vector2Like): boolean {
-		return equals(this, vector);
+	public add(vector: Readonly<Vector2Like>): Vector2 {
+		return add(this, vector, new Vector2());
 	}
 
 	/**
-	 * Determine whether or not this vector is exactly equivalent to another.
+	 * Get the angle from this to another vector in radians.
 	 * @param vector - The other vector.
-	 * @returns Whether or not the vectors are equivalent.
+	 * @returns The angular distance.
 	 */
-	public exactEquals(vector: Vector2Like): boolean {
-		return exactEquals(this, vector);
+	public angle(vector: Readonly<Vector2Like>): number {
+		return angle(this, vector);
 	}
 
 	/**
-	 * Add another vector to this one.
-	 * @param vector - The other vector.
-	 * @returns The sum of the vectors.
+	 * Round up the components of this vector.
+	 * @returns The rounded vector.
 	 */
-	public add(vector: Vector2Like): Vector2 {
-		return add(this, vector, new Vector2());
+	public ceil(): Vector2 {
+		return ceil(this, new Vector2());
 	}
 
 	/**
@@ -593,17 +651,28 @@ export default class Vector2
 	 * @param vector - The vector to copy.
 	 * @returns This vector.
 	 */
-	public copy(vector: Vector2Like): this {
+	public copy(vector: Readonly<Vector2Like>): this {
 		return copy(vector, this);
 	}
 
 	/**
-	 * Multiply the components in this vector by the corresponding components in another.
+	 * Calculate the cross product of this and another vector.
 	 * @param vector - The other vector.
-	 * @returns The product of the vectors.
+	 * @returns The cross product.
+	 * @see {@link https://en.wikipedia.org/wiki/Cross_product | Cross product}
 	 */
-	public multiply(vector: Vector2Like): Vector2 {
-		return multiply(this, vector, new Vector2());
+	public cross(vector: Readonly<Vector2Like>): Vector3 {
+		return cross(this, vector, new Vector3());
+	}
+
+	/**
+	 * Calculate the Euclidean distance from this vector to another.
+	 * @param vector - The other vector.
+	 * @returns The distance.
+	 * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
+	 */
+	public distance(vector: Readonly<Vector2Like>): number {
+		return distance(this, vector);
 	}
 
 	/**
@@ -611,33 +680,36 @@ export default class Vector2
 	 * @param vector - The other vector.
 	 * @returns The quotient of the vectors.
 	 */
-	public divide(vector: Vector2Like): Vector2 {
+	public divide(vector: Readonly<Vector2Like>): Vector2 {
 		return divide(this, vector, new Vector2());
 	}
 
 	/**
-	 * 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: Vector2Like): Vector2 {
-		return subtract(this, vector, new Vector2());
+	public dot(vector: Readonly<Vector2Like>): number {
+		return dot(this, vector);
 	}
 
 	/**
-	 * Absolutize the components of this vector.
-	 * @returns The absolutized vector.
+	 * Determine whether this vector is roughly equivalent to another.
+	 * @param vector - The other vector.
+	 * @returns Whether the vectors are equivalent.
 	 */
-	public abs(): Vector2 {
-		return abs(this, new Vector2());
+	public equals(vector: Readonly<Vector2Like>): boolean {
+		return equals(this, vector);
 	}
 
 	/**
-	 * Round up the components of this vector.
-	 * @returns The rounded vector.
+	 * Determine whether or not this vector is exactly equivalent to another.
+	 * @param vector - The other vector.
+	 * @returns Whether or not the vectors are equivalent.
 	 */
-	public ceil(): Vector2 {
-		return ceil(this, new Vector2());
+	public exactEquals(vector: Readonly<Vector2Like>): boolean {
+		return exactEquals(this, vector);
 	}
 
 	/**
@@ -649,20 +721,22 @@ export default class Vector2
 	}
 
 	/**
-	 * 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(): Vector2 {
-		return round(this, new Vector2());
+	public invert(): Vector2 {
+		return invert(this, new Vector2());
 	}
 
 	/**
-	 * 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.
+	 * @see {@link https://en.wikipedia.org/wiki/Linear_interpolation | Linear interpolation}
 	 */
-	public min(vector: Vector2Like): Vector2 {
-		return min(this, vector, new Vector2());
+	public lerp(vector: Readonly<Vector2Like>, t: number): Vector2 {
+		return lerp(this, vector, t, new Vector2());
 	}
 
 	/**
@@ -670,139 +744,117 @@ export default class Vector2
 	 * @param vector - The other vector.
 	 * @returns The maximum.
 	 */
-	public max(vector: Vector2Like): Vector2 {
+	public max(vector: Readonly<Vector2Like>): Vector2 {
 		return max(this, vector, new Vector2());
 	}
 
 	/**
-	 * 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).
+	 * Return the minimum of this and another vector.
+	 * @param vector - The other vector.
+	 * @returns The minimum.
 	 */
-	public pow(scalar: number): Vector2 {
-		return pow(this, scalar, new Vector2());
+	public min(vector: Readonly<Vector2Like>): Vector2 {
+		return min(this, vector, new Vector2());
 	}
 
 	/**
-	 * Scale this vector by a scalar.
-	 * @param scalar - The scalar.
-	 * @returns The scaled vector.
+	 * Multiply the components in this vector by the corresponding components in another.
+	 * @param vector - The other vector.
+	 * @returns The product of the vectors.
 	 */
-	public scale(scalar: number): Vector2 {
-		return scale(this, scalar, new Vector2());
+	public multiply(vector: Readonly<Vector2Like>): Vector2 {
+		return multiply(this, vector, new Vector2());
 	}
 
 	/**
-	 * 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.
+	 * Negate this vector.
+	 * @returns The negated vector.
 	 */
-	public scaleAndAdd(vector: Vector2Like, scalar: number): Vector2 {
-		return scaleAndAdd(this, vector, scalar, new Vector2());
+	public negate(): Vector2 {
+		return negate(this, new Vector2());
 	}
 
 	/**
-	 * Calculate the Euclidean distance from this vector to another.
-	 * @param vector - The other vector.
-	 * @returns The distance.
-	 * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
+	 * Normalize this vector.
+	 * @returns The normalized vector.
+	 * @see {@link https://en.wikipedia.org/wiki/Unit_vector | Unit vector}
 	 */
-	public distance(vector: Vector2Like): number {
-		return distance(this, vector);
+	public normalize(): Vector2 {
+		return normalize(this, new Vector2());
 	}
 
 	/**
-	 * Calculate the squared Euclidean distance from this vector to another.
-	 * @param vector - The other vector.
-	 * @returns The squared distance.
-	 * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
+	 * 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 squaredDistance(vector: Vector2Like): number {
-		return squaredDistance(this, vector);
-	}
-
-	/** The magnitude (length) of this vector. */
-	public get magnitude(): number {
-		return getMagnitude(this);
-	}
-
-	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);
+	public pow(scalar: number): Vector2 {
+		return pow(this, scalar, new Vector2());
 	}
 
 	/**
-	 * Negate this vector.
-	 * @returns The negated vector.
+	 * Set this vector to a random value with the given magnitude.
+	 * @param magnitude - The magnitude.
+	 * @returns This vector.
 	 */
-	public negate(): Vector2 {
-		return negate(this, new Vector2());
+	public random(magnitude = 1): this {
+		return random(magnitude, this);
 	}
 
 	/**
-	 * Calculate the multiplicative inverse of the components of this vector.
-	 * @returns The inverted vector.
+	 * Rotate this vector.
+	 * @param origin - The origin of the rotation.
+	 * @param radians - The angle of rotation in radians.
+	 * @returns The rotated vector.
 	 */
-	public invert(): Vector2 {
-		return invert(this, new Vector2());
+	public rotate(origin: Readonly<Vector2Like>, radians: number): Vector2 {
+		return rotate(this, origin, radians, new Vector2());
 	}
 
 	/**
-	 * Normalize this vector.
-	 * @returns The normalized vector.
-	 * @see {@link https://en.wikipedia.org/wiki/Unit_vector | Unit vector}
+	 * Round the components of this vector.
+	 * @returns The rounded vector.
 	 */
-	public normalize(): Vector2 {
-		return normalize(this, new Vector2());
+	public round(): Vector2 {
+		return round(this, new Vector2());
 	}
 
 	/**
-	 * Calculate the dot product of this and another vector.
-	 * @param vector - The other vector.
-	 * @returns The dot product.
-	 * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
+	 * Scale this vector by a scalar.
+	 * @param scalar - The scalar.
+	 * @returns The scaled vector.
 	 */
-	public dot(vector: Vector2Like): number {
-		return dot(this, vector);
+	public scale(scalar: number): Vector2 {
+		return scale(this, scalar, new Vector2());
 	}
 
 	/**
-	 * Calculate the cross product of this and another vector.
+	 * Add another vector to this one after scaling the other by a scalar.
 	 * @param vector - The other vector.
-	 * @returns The cross product.
-	 * @see {@link https://en.wikipedia.org/wiki/Cross_product | Cross product}
+	 * @param scalar - The scalar.
+	 * @returns The sum.
 	 */
-	public cross(vector: Vector2Like): Vector3 {
-		return cross(this, vector, new Vector3());
+	public scaleAndAdd(vector: Readonly<Vector2Like>, scalar: number): Vector2 {
+		return scaleAndAdd(this, vector, scalar, new Vector2());
 	}
 
 	/**
-	 * Perform a linear interpolation between this and another vector.
+	 * Calculate the squared Euclidean distance from this vector to another.
 	 * @param vector - The other vector.
-	 * @param t - The interpolation amount (in `[0,1]`).
-	 * @returns The interpolated vector.
-	 * @see {@link https://en.wikipedia.org/wiki/Linear_interpolation | Linear interpolation}
+	 * @returns The squared distance.
+	 * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
 	 */
-	public lerp(vector: Vector2Like, t: number): Vector2 {
-		return lerp(this, vector, t, new Vector2());
+	public squaredDistance(vector: Readonly<Vector2Like>): number {
+		return squaredDistance(this, vector);
 	}
 
 	/**
-	 * Set this vector to a random value with the given magnitude.
-	 * @param magnitude - The magnitude.
-	 * @returns This vector.
+	 * Subtract another vector from this one.
+	 * @param vector - The other vector.
+	 * @returns The difference between the vectors.
 	 */
-	public random(magnitude = 1): this {
-		return random(magnitude, this);
+	public subtract(vector: Readonly<Vector2Like>): Vector2 {
+		return subtract(this, vector, new Vector2());
 	}
 
 	/**
@@ -811,7 +863,7 @@ export default class Vector2
 	 * @returns The transformed vector.
 	 * @see {@link https://en.wikipedia.org/wiki/Transformation_matrix | Transformation matrix}
 	 */
-	public transformMatrix2(matrix: Matrix2Like): Vector2 {
+	public transformMatrix2(matrix: Readonly<Matrix2Like>): Vector2 {
 		return transformMatrix2(this, matrix, new Vector2());
 	}
 
@@ -821,7 +873,7 @@ export default class Vector2
 	 * @returns The transformed vector.
 	 * @see {@link https://en.wikipedia.org/wiki/Transformation_matrix | Transformation matrix}
 	 */
-	public transformMatrix3(matrix: Matrix3Like): Vector2 {
+	public transformMatrix3(matrix: Readonly<Matrix3Like>): Vector2 {
 		return transformMatrix3(this, matrix, new Vector2());
 	}
 
@@ -831,29 +883,10 @@ export default class Vector2
 	 * @returns The transformed vector.
 	 * @see {@link https://en.wikipedia.org/wiki/Transformation_matrix | Transformation matrix}
 	 */
-	public transformMatrix4(matrix: Matrix4Like): Vector2 {
+	public transformMatrix4(matrix: Readonly<Matrix4Like>): Vector2 {
 		return transformMatrix4(this, matrix, new Vector2());
 	}
 
-	/**
-	 * Rotate this vector.
-	 * @param origin - The origin of the rotation.
-	 * @param radians - The angle of rotation in radians.
-	 * @returns The rotated vector.
-	 */
-	public rotate(origin: Vector2Like, radians: number): Vector2 {
-		return rotate(this, origin, radians, new Vector2());
-	}
-
-	/**
-	 * Get the angle from this to another vector in radians.
-	 * @param vector - The other vector.
-	 * @returns The angular distance.
-	 */
-	public angle(vector: Vector2Like): number {
-		return angle(this, vector);
-	}
-
 	/**
 	 * Set this to the zero vector.
 	 * @returns This vector.