@lakuna/umath 1.5.0 → 3.0.0

package/src/linalg/Quaternion.ts

@@ -1,15 +1,20 @@
+import type AxisAngle from "../types/AxisAngle.js";
+
+import radiansToDegrees from "../algorithms/radiansToDegrees.js";
+import createAxisAngleLike from "../utility/createAxisAngleLike.js";
+import epsilon from "../utility/epsilon.js";
 import {
-	type Matrix3Like,
 	createMatrix3Like,
-	fromValues as matrix3FromValues
+	fromValues as matrix3FromValues,
+	type Matrix3Like
 } from "./Matrix3.js";
 import Vector3, {
-	type Vector3Like,
 	createVector3Like,
 	cross as vector3Cross,
 	dot as vector3Dot,
 	fromValues as vector3FromValues,
 	getMagnitude as vector3GetMagnitude,
+	type Vector3Like,
 	normalize as vector3Normalize
 } from "./Vector3.js";
 import {
@@ -24,9 +29,6 @@ import {
 	normalize as vector4Normalize,
 	scale as vector4Scale
 } from "./Vector4.js";
-import type AxisAngle from "../types/AxisAngle.js";
-import epsilon from "../utility/epsilon.js";
-import radiansToDegrees from "../algorithms/radiansToDegrees.js";
 
 /**
  * A complex number that is commonly used to describe rotations.
@@ -35,15 +37,19 @@ import radiansToDegrees from "../algorithms/radiansToDegrees.js";
  */
 export interface QuaternionLike extends Record<number, number> {
 	/** The first component of this quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	0: number;
 
 	/** The second component of this quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	1: number;
 
 	/** The third component of this quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	2: number;
 
 	/** The fourth component of this quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	3: number;
 }
 
@@ -52,9 +58,9 @@ export interface QuaternionLike extends Record<number, number> {
  * @returns A quaternion-like object.
  * @public
  */
-export const createQuaternionLike = (): Float32Array & QuaternionLike => {
-	return new Float32Array(4) as Float32Array & QuaternionLike;
-};
+export const createQuaternionLike = (): Float32Array & QuaternionLike =>
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+	new Float32Array(4) as Float32Array & QuaternionLike;
 
 /**
  * Create a quaternion with the given values.
@@ -222,28 +228,37 @@ export const fromMatrix3 = <T extends QuaternionLike>(
 	if (m4 > m0) {
 		i = 1;
 	}
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
 	if (m8 > matrix[(i * 3 + i) as 0 | 4]) {
 		i = 2;
 	}
-	const j = ((i + 1) % 3) as 1 | 2 | 0;
-	const k = ((i + 2) % 3) as 2 | 0 | 1;
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+	const j = ((i + 1) % 3) as 0 | 1 | 2;
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+	const k = ((i + 2) % 3) as 0 | 1 | 2;
 
 	let fRoot: number = Math.sqrt(
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
 		matrix[(i * 3 + i) as 0 | 4 | 7] -
-			matrix[(j * 3 + j) as 4 | 7 | 0] -
-			matrix[(k * 3 + k) as 7 | 0 | 4] +
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+			matrix[(j * 3 + j) as 0 | 4 | 7] -
+			// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+			matrix[(k * 3 + k) as 0 | 4 | 7] +
 			1
 	);
 	out[i] = fRoot / 2;
 	fRoot = 0.5 / fRoot;
 	out[3] =
-		(matrix[(j * 3 + k) as 5 | 6 | 1] - matrix[(k * 3 + j) as 7 | 2 | 3]) *
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+		(matrix[(j * 3 + k) as 1 | 5 | 6] - matrix[(k * 3 + j) as 2 | 3 | 7]) *
 		fRoot;
 	out[j] =
-		(matrix[(j * 3 + i) as 3 | 7 | 2] + matrix[(i * 3 + j) as 1 | 5 | 6]) *
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+		(matrix[(j * 3 + i) as 2 | 3 | 7] + matrix[(i * 3 + j) as 1 | 5 | 6]) *
 		fRoot;
 	out[k] =
-		(matrix[(k * 3 + i) as 6 | 1 | 5] + matrix[(i * 3 + k) as 2 | 3 | 7]) *
+		// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+		(matrix[(k * 3 + i) as 1 | 5 | 6] + matrix[(i * 3 + k) as 2 | 3 | 7]) *
 		fRoot;
 	return out;
 };
@@ -826,7 +841,7 @@ export const exp = <T extends QuaternionLike>(
 	const y = quaternion[1];
 	const z = quaternion[2];
 
-	const r = Math.sqrt(x * x + y * y + z * z); // `Math.hypot` is slower.
+	const r = Math.hypot(x, y, z);
 	const et = Math.exp(quaternion[3]);
 	const s = r > 0 ? (et * Math.sin(r)) / r : 0;
 
@@ -850,7 +865,7 @@ export const ln = <T extends QuaternionLike>(
 	const w = quaternion[3];
 
 	const xyz2 = x * x + y * y + z * z;
-	const r = Math.sqrt(xyz2); // `Math.hypot` is slower.
+	const r = Math.sqrt(xyz2);
 	const t = r > 0 ? Math.atan2(r, w) / r : 0;
 
 	return fromValues(x * t, y * t, z * t, Math.log(xyz2 + w * w) / 2, out);
@@ -905,9 +920,9 @@ export const slerp = <T extends QuaternionLike>(
 		bw = -bw;
 	}
 
-	// eslint-disable-next-line init-declarations
+	// eslint-disable-next-line @typescript-eslint/init-declarations
 	let scale0;
-	// eslint-disable-next-line init-declarations
+	// eslint-disable-next-line @typescript-eslint/init-declarations
 	let scale1;
 	if (1 - cosom > epsilon) {
 		const omega = Math.acos(cosom);
@@ -1074,18 +1089,63 @@ export const fromRotationTo = <T extends QuaternionLike>(
  * @public
  */
 export default class Quaternion extends Float32Array implements QuaternionLike {
+	/** The first component of this quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 0: number;
+
+	/** The second component of this quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 1: number;
+
+	/** The third component of this quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 2: number;
+
+	/** The fourth component of this quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 3: number;
+
+	/** The axis and angle that represent this quaternion. */
+	public get axisAngle(): ReturnType<typeof createAxisAngleLike> {
+		return getAxisAngle(this, createAxisAngleLike());
+	}
+
+	public set axisAngle(value: AxisAngle) {
+		setAxisAngle(value, this);
+	}
+
+	/** Get the magnitude (length) of this quaternion. */
+	public get magnitude(): number {
+		return getMagnitude(this);
+	}
+
+	/** Get the squared magnitude (length) of this quaternion. */
+	public get squaredMagnitude(): number {
+		return getSquaredMagnitude(this);
+	}
+
 	/**
-	 * Create a quaternion from a three-by-three rotation matrix.
-	 * @param matrix - The matrix.
-	 * @param out - The quaternion to store the result in.
+	 * Create an identity quaternion.
+	 * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
+	 */
+	public constructor() {
+		super(4);
+		this[3] = 1;
+	}
+
+	/**
+	 * Create a quaternion with values corresponding to the given orthonormal set of vectors.
+	 * @param view - The vector representing the viewing direction.
+	 * @param right - The vector representing the local "right" direction.
+	 * @param up - The vector representing the local "up" direction.
 	 * @returns The quaternion.
-	 * @see {@link https://en.wikipedia.org/wiki/Rotation_matrix | Rotation matrix}
 	 */
-	public static fromMatrix3<T extends QuaternionLike = Quaternion>(
-		matrix: Matrix3Like,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return fromMatrix3(matrix, out);
+	public static fromAxes(
+		view: Vector3Like,
+		right: Vector3Like,
+		up: Vector3Like
+	): Quaternion {
+		return fromAxes(view, right, up, new Quaternion());
 	}
 
 	/**
@@ -1093,17 +1153,31 @@ export default class Quaternion extends Float32Array implements QuaternionLike {
 	 * @param z - The z (roll) angle.
 	 * @param y - The y (pitch) angle.
 	 * @param x - The x (yaw) angle.
-	 * @param out - The quaternion to store the result in.
 	 * @returns The quaternion.
 	 * @see {@link https://en.wikipedia.org/wiki/Euler_angles | Euler angles}
 	 */
-	public static fromEuler<T extends QuaternionLike = Quaternion>(
-		z: number,
-		y: number,
-		x: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return fromEuler(z, y, x, out);
+	public static fromEuler(z: number, y: number, x: number): Quaternion {
+		return fromEuler(z, y, x, new Quaternion());
+	}
+
+	/**
+	 * Create a quaternion from a three-by-three rotation matrix.
+	 * @param matrix - The matrix.
+	 * @returns The quaternion.
+	 * @see {@link https://en.wikipedia.org/wiki/Rotation_matrix | Rotation matrix}
+	 */
+	public static fromMatrix3(matrix: Matrix3Like): Quaternion {
+		return fromMatrix3(matrix, new Quaternion());
+	}
+
+	/**
+	 * Create a unit quaternion that represents the shortest rotation from one unit vector to another.
+	 * @param a - The first unit vector.
+	 * @param b - The second unit vector.
+	 * @returns The unit quaternion.
+	 */
+	public static fromRotationTo(a: Vector3Like, b: Vector3Like): Quaternion {
+		return fromRotationTo(a, b, new Quaternion());
 	}
 
 	/**
@@ -1112,358 +1186,216 @@ export default class Quaternion extends Float32Array implements QuaternionLike {
 	 * @param y - The second component.
 	 * @param z - The third component.
 	 * @param w - The fourth component.
-	 * @param out - The quaternion to store the result in.
 	 * @returns A new quaternion.
 	 */
-	public static fromValues<T extends QuaternionLike = Quaternion>(
+	public static fromValues(
 		x: number,
 		y: number,
 		z: number,
-		w: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return fromValues(x, y, z, w, out);
+		w: number
+	): Quaternion {
+		return fromValues(x, y, z, w, new Quaternion());
 	}
 
 	/**
-	 * Create a quaternion with values corresponding to the given orthonormal set of vectors.
-	 * @param view - The vector representing the viewing direction.
-	 * @param right - The vector representing the local "right" direction.
-	 * @param up - The vector representing the local "up" direction.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The quaternion.
+	 * Add two quaternions of the same size.
+	 * @param quaternion - The other quaternion.
+	 * @returns The sum of the quaternions.
 	 */
-	public static fromAxes<T extends QuaternionLike = Quaternion>(
-		view: Vector3Like,
-		right: Vector3Like,
-		up: Vector3Like,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return fromAxes(view, right, up, out);
+	public add(quaternion: QuaternionLike): Quaternion {
+		return add(this, quaternion, new Quaternion());
 	}
 
 	/**
-	 * Create a unit quaternion that represents the shortest rotation from one unit vector to another.
-	 * @param a - The first unit vector.
-	 * @param b - The second unit vector.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The unit quaternion.
+	 * Calculate the fourth component of this unit quaternion from the first three, ignoring the existing fourth component.
+	 * @returns The quaternion.
 	 */
-	public static fromRotationTo<T extends QuaternionLike = Quaternion>(
-		a: Vector3Like,
-		b: Vector3Like,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return fromRotationTo(a, b, out);
+	public calculateW(): Quaternion {
+		return calculateW(this, new Quaternion());
 	}
 
 	/**
-	 * Create an identity quaternion.
-	 * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
+	 * Copy the values from this quaternion to another one.
+	 * @returns The copy.
 	 */
-	public constructor() {
-		super(4);
-		this[3] = 1;
+	public clone(): Quaternion {
+		return copy(this, new Quaternion());
 	}
 
-	/** The first component of this quaternion. */
-	public 0: number;
-
-	/** The second component of this quaternion. */
-	public 1: number;
-
-	/** The third component of this quaternion. */
-	public 2: number;
-
-	/** The fourth component of this quaternion. */
-	public 3: number;
-
 	/**
-	 * Set this quaternion to the identity.
-	 * @returns This quaternion.
+	 * Calculate the conjugate of this quaternion. If the quaternion is normalized, this is the same as the inverse but faster to calculate.
+	 * @returns The conjugate.
 	 */
-	public identity(): this {
-		return identity(this);
+	public conjugate(): Quaternion {
+		return conjugate(this, new Quaternion());
 	}
 
 	/**
-	 * Get the axis and angle that represent this quaternion.
-	 * @param out - The axis and angle to store the result in.
-	 * @returns The axis and angle.
+	 * Copy the values of another quaternion into this one.
+	 * @param quaternion - The quaternion to copy.
+	 * @returns This quaternion.
 	 */
-	public getAxisAngle<T extends AxisAngle>(out = {} as T): T {
-		return getAxisAngle(this, out);
+	public copy(quaternion: QuaternionLike): this {
+		return copy(quaternion, this);
 	}
 
 	/**
-	 * Set the axis and angle that represent this quaternion.
-	 * @param axisAngle - The axis and angle.
-	 * @returns This quaternion.
+	 * Calculate the dot product of this and another quaternion.
+	 * @param quaternion - The other quaternion.
+	 * @returns The dot product.
 	 */
-	public setAxisAngle(axisAngle: AxisAngle): this {
-		return setAxisAngle(axisAngle, this);
+	public dot(quaternion: QuaternionLike): number {
+		return dot(this, quaternion);
 	}
 
 	/**
-	 * Get the angular distance between this unit quaternion and another.
-	 * @param quaternion - The other unit quaternion.
-	 * @returns The angular distance in radians.
+	 * Determine whether or not this quaternion is roughly equivalent to another.
+	 * @param quaternion - The other quaternion.
+	 * @returns Whether or not the quaternions are equivalent.
 	 */
-	public getAngle(quaternion: QuaternionLike): number {
-		return getAngle(this, quaternion);
+	public equals(quaternion: QuaternionLike): boolean {
+		return equals(this, quaternion);
 	}
 
 	/**
-	 * Multiply this and another quaternion.
+	 * Determine whether or not this quaternion is exactly equivalent to another.
 	 * @param quaternion - The other quaternion.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The product.
+	 * @returns Whether or not the quaternions are equivalent.
 	 */
-	public multiply<T extends QuaternionLike = Quaternion>(
-		quaternion: QuaternionLike,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return multiply(this, quaternion, out);
+	public exactEquals(quaternion: QuaternionLike): boolean {
+		return exactEquals(this, quaternion);
 	}
 
 	/**
-	 * Rotate this quaternion by the given angle around the X-axis.
-	 * @param r - The angle in radians.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The rotated quaternion.
+	 * Calculate the exponential of this unit quaternion.
+	 * @returns The exponential.
 	 */
-	public rotateX<T extends QuaternionLike = Quaternion>(
-		r: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return rotateX(this, r, out);
+	public exp(): Quaternion {
+		return exp(this, new Quaternion());
 	}
 
 	/**
-	 * Rotate this quaternion by the given angle around the Y-axis.
-	 * @param r - The angle in radians.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The rotated quaternion.
+	 * Get the angular distance between this unit quaternion and another.
+	 * @param quaternion - The other unit quaternion.
+	 * @returns The angular distance in radians.
 	 */
-	public rotateY<T extends QuaternionLike = Quaternion>(
-		r: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return rotateY(this, r, out);
+	public getAngle(quaternion: QuaternionLike): number {
+		return getAngle(this, quaternion);
 	}
 
 	/**
-	 * Rotate this quaternion by the given angle around the Z-axis.
-	 * @param r - The angle in radians.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The rotated quaternion.
+	 * Set this quaternion to the identity.
+	 * @returns This quaternion.
 	 */
-	public rotateZ<T extends QuaternionLike = Quaternion>(
-		r: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return rotateZ(this, r, out);
+	public identity(): this {
+		return identity(this);
 	}
 
 	/**
-	 * Calculate the fourth component of this unit quaternion from the first three, ignoring the existing fourth component.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The quaternion.
+	 * Calculate the inverse of this quaternion. If the quaternion is normalized, the conjugate is the same but faster to calculate.
+	 * @returns The inverse.
 	 */
-	public calculateW<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return calculateW(this, out);
+	public invert(): Quaternion {
+		return invert(this, new Quaternion());
 	}
 
 	/**
-	 * Calculate the exponential of this unit quaternion.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The exponential.
+	 * Perform a linear interpolation between this and another quaternion.
+	 * @param quaternion - The other quaternion.
+	 * @param t - The interpolation amount (in `[0,1]`).
+	 * @returns The interpolated quaternion.
 	 */
-	public exp<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return exp(this, out);
+	public lerp(quaternion: QuaternionLike, t: number): Quaternion {
+		return lerp(this, quaternion, t, new Quaternion());
 	}
 
 	/**
 	 * Calculate the natural logarithm of this unit quaternion.
-	 * @param out - The quaternion to store the result in.
 	 * @returns The natural logarithm.
 	 */
-	public ln<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return ln(this, out);
-	}
-
-	/**
-	 * Calculate a power of this unit quaternion.
-	 * @param scalar - The amount to scale the quaternion by.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The power.
-	 */
-	public pow<T extends QuaternionLike = Quaternion>(
-		scalar: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return pow(this, scalar, out);
+	public ln(): Quaternion {
+		return ln(this, new Quaternion());
 	}
 
 	/**
-	 * Perform a spherical linear interpolation between this and another quaternion.
+	 * Multiply this and another quaternion.
 	 * @param quaternion - The other quaternion.
-	 * @param t - The interpolation amount in `[0,1]`.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The interpolated quaternion.
-	 * @see {@link https://en.wikipedia.org/wiki/Slerp | Slerp}
+	 * @returns The product.
 	 */
-	public slerp<T extends QuaternionLike = Quaternion>(
-		quaternion: QuaternionLike,
-		t: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return slerp(this, quaternion, t, out);
+	public multiply(quaternion: QuaternionLike): Quaternion {
+		return multiply(this, quaternion, new Quaternion());
 	}
 
 	/**
-	 * Set this to a random unit quaternion.
-	 * @returns A random unit quaternion.
+	 * Normalize this quaternion.
+	 * @returns The normalized quaternion.
 	 */
-	public random(): this {
-		return random(this);
+	public normalize(): Quaternion {
+		return normalize(this, new Quaternion());
 	}
 
 	/**
-	 * Calculate the inverse of this quaternion. If the quaternion is normalized, the conjugate is the same but faster to calculate.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The inverse.
+	 * Calculate a power of this unit quaternion.
+	 * @param scalar - The amount to scale the quaternion by.
+	 * @returns The power.
 	 */
-	public invert<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return invert(this, out);
+	public pow(scalar: number): Quaternion {
+		return pow(this, scalar, new Quaternion());
 	}
 
 	/**
-	 * Calculate the conjugate of this quaternion. If the quaternion is normalized, this is the same as the inverse but faster to calculate.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The conjugate.
+	 * Set this to a random unit quaternion.
+	 * @returns A random unit quaternion.
 	 */
-	public conjugate<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return conjugate(this, out);
+	public random(): this {
+		return random(this);
 	}
 
 	/**
-	 * Copy the values from this quaternion to another one.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The copy.
+	 * Rotate this quaternion by the given angle around the X-axis.
+	 * @param r - The angle in radians.
+	 * @returns The rotated quaternion.
 	 */
-	public clone<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return copy(this, out);
+	public rotateX(r: number): Quaternion {
+		return rotateX(this, r, new Quaternion());
 	}
 
 	/**
-	 * Copy the values of another quaternion into this one.
-	 * @param quaternion - The quaternion to copy.
-	 * @returns This quaternion.
+	 * Rotate this quaternion by the given angle around the Y-axis.
+	 * @param r - The angle in radians.
+	 * @returns The rotated quaternion.
 	 */
-	public copy(quaternion: QuaternionLike): this {
-		return copy(quaternion, this);
+	public rotateY(r: number): Quaternion {
+		return rotateY(this, r, new Quaternion());
 	}
 
 	/**
-	 * Add two quaternions of the same size.
-	 * @param quaternion - The other quaternion.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The sum of the quaternions.
+	 * Rotate this quaternion by the given angle around the Z-axis.
+	 * @param r - The angle in radians.
+	 * @returns The rotated quaternion.
 	 */
-	public add<T extends QuaternionLike = Quaternion>(
-		quaternion: QuaternionLike,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return add(this, quaternion, out);
+	public rotateZ(r: number): Quaternion {
+		return rotateZ(this, r, new Quaternion());
 	}
 
 	/**
 	 * Scale this quaternion by a scalar.
 	 * @param scalar - The scalar.
-	 * @param out - The quaternion to store the result in.
 	 * @returns The scaled quaternion.
 	 */
-	public scale<T extends QuaternionLike = Quaternion>(
-		scalar: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return scale(this, scalar, out);
+	public scale(scalar: number): Quaternion {
+		return scale(this, scalar, new Quaternion());
 	}
 
 	/**
-	 * Calculate the dot product of this and another quaternion.
-	 * @param quaternion - The other quaternion.
-	 * @returns The dot product.
-	 */
-	public dot(quaternion: QuaternionLike): number {
-		return dot(this, quaternion);
-	}
-
-	/**
-	 * Perform a linear interpolation between this and another quaternion.
+	 * Perform a spherical linear interpolation between this and another quaternion.
 	 * @param quaternion - The other quaternion.
-	 * @param t - The interpolation amount (in `[0,1]`).
-	 * @param out - The quaternion to store the result in.
+	 * @param t - The interpolation amount in `[0,1]`.
 	 * @returns The interpolated quaternion.
+	 * @see {@link https://en.wikipedia.org/wiki/Slerp | Slerp}
 	 */
-	public lerp<T extends QuaternionLike = Quaternion>(
-		quaternion: QuaternionLike,
-		t: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return lerp(this, quaternion, t, out);
-	}
-
-	/** Get the magnitude (length) of this quaternion. */
-	public get magnitude(): number {
-		return getMagnitude(this);
-	}
-
-	/** Get the squared magnitude (length) of this quaternion. */
-	public get squaredMagnitude(): number {
-		return getSquaredMagnitude(this);
-	}
-
-	/**
-	 * Normalize this quaternion.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The normalized quaternion.
-	 */
-	public normalize<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return normalize(this, out);
-	}
-
-	/**
-	 * Determine whether or not this quaternion is roughly equivalent to another.
-	 * @param quaternion - The other quaternion.
-	 * @returns Whether or not the quaternions are equivalent.
-	 */
-	public equals(quaternion: QuaternionLike): boolean {
-		return equals(this, quaternion);
-	}
-
-	/**
-	 * Determine whether or not this quaternion is exactly equivalent to another.
-	 * @param quaternion - The other quaternion.
-	 * @returns Whether or not the quaternions are equivalent.
-	 */
-	public exactEquals(quaternion: QuaternionLike): boolean {
-		return exactEquals(this, quaternion);
+	public slerp(quaternion: QuaternionLike, t: number): Quaternion {
+		return slerp(this, quaternion, t, new Quaternion());
 	}
 
 	/**
@@ -1472,28 +1404,23 @@ export default class Quaternion extends Float32Array implements QuaternionLike {
 	 * @param b - The second control point.
 	 * @param quaternion - The other quaternion.
 	 * @param t - The interpolation amount in `[0,1]`.
-	 * @param out - The quaternion to store the result in.
 	 * @returns The interpolated value.
 	 * @see {@link https://en.wikipedia.org/wiki/Slerp | Slerp}
 	 */
-	public sqlerp<T extends QuaternionLike = Quaternion>(
+	public sqlerp(
 		a: QuaternionLike,
 		b: QuaternionLike,
 		quaternion: QuaternionLike,
-		t: number,
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return sqlerp(this, a, b, quaternion, t, out);
+		t: number
+	): Quaternion {
+		return sqlerp(this, a, b, quaternion, t, new Quaternion());
 	}
 
 	/**
 	 * Convert this quaternion to equivalent z-y'-x" (intrinsic) Tait-Bryan angles.
-	 * @param out - The vector in which to store the Tait-Bryan angles.
 	 * @returns The Tait-Bryan angles in degrees in roll (z), pitch (y'), yaw (x") order.
 	 */
-	public toEuler<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return toEuler(this, out);
+	public toEuler(): Vector3 {
+		return toEuler(this, new Vector3());
 	}
 }