@lakuna/umath 1.5.0 → 3.0.0

package/src/linalg/DualQuaternion.ts

@@ -1,6 +1,8 @@
+import approxRelative from "../algorithms/approxRelative.js";
+import epsilon from "../utility/epsilon.js";
 import {
-	type Matrix4Like,
-	getScaling as matrix4GetScaling
+	getScaling as matrix4GetScaling,
+	type Matrix4Like
 } from "./Matrix4.js";
 import Quaternion, {
 	type QuaternionLike,
@@ -9,9 +11,9 @@ import Quaternion, {
 	rotateZ as quaternionRotateZ
 } from "./Quaternion.js";
 import Vector3, {
-	type Vector3Like,
 	createVector3Like,
-	fromValues as vector3FromValues
+	fromValues as vector3FromValues,
+	type Vector3Like
 } from "./Vector3.js";
 import {
 	copy as vector4Copy,
@@ -20,8 +22,6 @@ import {
 	getMagnitude as vector4GetMagnitude,
 	getSquaredMagnitude as vector4GetSquaredMagnitude
 } from "./Vector4.js";
-import approxRelative from "../algorithms/approxRelative.js";
-import epsilon from "../utility/epsilon.js";
 
 /**
  * A complex number that is commonly used to describe transformations.
@@ -29,27 +29,35 @@ import epsilon from "../utility/epsilon.js";
  */
 export interface DualQuaternionLike extends Record<number, number> {
 	/** The first real component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	0: number;
 
 	/** The second real component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	1: number;
 
 	/** The third real component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	2: number;
 
 	/** The fourth real component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	3: number;
 
 	/** The first dual component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	4: number;
 
 	/** The second dual component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	5: number;
 
 	/** The third dual component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	6: number;
 
 	/** The fourth dual component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
 	7: number;
 }
 
@@ -58,10 +66,9 @@ export interface DualQuaternionLike extends Record<number, number> {
  * @returns A dual quaternion-like object.
  * @public
  */
-export const createDualQuaternionLike = (): Float32Array &
-	DualQuaternionLike => {
-	return new Float32Array(8) as Float32Array & DualQuaternionLike;
-};
+export const createDualQuaternionLike = (): DualQuaternionLike & Float32Array =>
+	// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+	new Float32Array(8) as DualQuaternionLike & Float32Array;
 
 /**
  * Create a dual quaternion with the given values.
@@ -235,13 +242,13 @@ export const fromMatrix4 = <T extends DualQuaternionLike>(
 
 	const trace = sm11 + sm22 + sm33;
 
-	// eslint-disable-next-line init-declarations
+	// eslint-disable-next-line @typescript-eslint/init-declarations
 	let x;
-	// eslint-disable-next-line init-declarations
+	// eslint-disable-next-line @typescript-eslint/init-declarations
 	let y;
-	// eslint-disable-next-line init-declarations
+	// eslint-disable-next-line @typescript-eslint/init-declarations
 	let z;
-	// eslint-disable-next-line init-declarations
+	// eslint-disable-next-line @typescript-eslint/init-declarations
 	let w;
 	if (trace > 0) {
 		const s = Math.sqrt(trace + 1) * 2;
@@ -653,7 +660,7 @@ export const rotateAroundAxis = <T extends DualQuaternionLike>(
 	const ax = axis[0];
 	const ay = axis[1];
 	const az = axis[2];
-	const axisLength = Math.sqrt(ax * ax + ay * ay + az * az); // `Math.hypot` is slower.
+	const axisLength = Math.hypot(ax, ay, az);
 
 	const r = radians / 2;
 
@@ -1007,121 +1014,146 @@ export default class DualQuaternion
 	extends Float32Array
 	implements DualQuaternionLike
 {
+	/** The first real component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 0: number;
+
+	/** The second real component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 1: number;
+
+	/** The third real component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 2: number;
+
+	/** The fourth real component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 3: number;
+
+	/** The first dual component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 4: number;
+
+	/** The second dual component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 5: number;
+
+	/** The third dual component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 6: number;
+
+	/** The fourth dual component of this dual quaternion. */
+	// eslint-disable-next-line @typescript-eslint/naming-convention
+	public 7: number;
+
+	/** Get the magnitude (length) of this dual quaternion. */
+	public get magnitude(): number {
+		return getMagnitude(this);
+	}
+
+	/** Get the squared magnitude (length) of this dual quaternion. */
+	public get squaredMagnitude(): number {
+		return getSquaredMagnitude(this);
+	}
+
 	/**
-	 * Create a dual quaternion with the given values.
-	 * @param x1 - The first real component.
-	 * @param y1 - The second real component.
-	 * @param z1 - The third real component.
-	 * @param w1 - The fourth real component.
-	 * @param x2 - The first dual component.
-	 * @param y2 - The second dual component.
-	 * @param z2 - The third dual component.
-	 * @param w2 - The fourth dual component.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns A new dual quaternion.
+	 * Create an identity dual quaternion.
+	 * @see {@link https://en.wikipedia.org/wiki/Dual_quaternion | Dual quaternion}
 	 */
-	public static fromValues<T extends DualQuaternionLike = DualQuaternion>(
-		x1: number,
-		y1: number,
-		z1: number,
-		w1: number,
-		x2: number,
-		y2: number,
-		z2: number,
-		w2: number,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return fromValues(x1, y1, z1, w1, x2, y2, z2, w2, out);
+	public constructor() {
+		super(8);
+		this[3] = 1;
 	}
 
 	/**
-	 * Create a dual quaternion from the given rotation and translation.
-	 * @param q - The rotation quaternion.
-	 * @param t - The translation vector.
-	 * @param out - The dual quaternion to store the result in.
+	 * Create a dual quaternion from the given four-by-four matrix.
+	 * @param matrix - The matrix.
 	 * @returns The dual quaternion.
 	 */
-	public static fromRotationTranslation<
-		T extends DualQuaternionLike = DualQuaternion
-	>(
-		q: QuaternionLike,
-		t: Vector3Like,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return fromRotationTranslation(q, t, out);
+	public static fromMatrix4(matrix: Matrix4Like): DualQuaternion {
+		return fromMatrix4(matrix, new DualQuaternion());
 	}
 
 	/**
-	 * Create a dual quaternion from the given translation.
-	 * @param t - The translation vector.
-	 * @param out - The dual quaternion to store the result in.
+	 * Create a dual quaternion from the given rotation.
+	 * @param q - The rotation quaternion.
 	 * @returns The dual quaternion.
 	 */
-	public static fromTranslation<T extends DualQuaternionLike = DualQuaternion>(
-		t: Vector3Like,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return fromTranslation(t, out);
+	public static fromRotation(q: QuaternionLike): DualQuaternion {
+		return fromRotation(q, new DualQuaternion());
 	}
 
 	/**
-	 * Create a dual quaternion from the given rotation.
+	 * Create a dual quaternion from the given rotation and translation.
 	 * @param q - The rotation quaternion.
-	 * @param out - The dual quaternion to store the result in.
+	 * @param t - The translation vector.
 	 * @returns The dual quaternion.
 	 */
-	public static fromRotation<T extends DualQuaternionLike = DualQuaternion>(
+	public static fromRotationTranslation(
 		q: QuaternionLike,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return fromRotation(q, out);
+		t: Vector3Like
+	): DualQuaternion {
+		return fromRotationTranslation(q, t, new DualQuaternion());
 	}
 
 	/**
-	 * Create a dual quaternion from the given four-by-four matrix.
-	 * @param matrix - The matrix.
-	 * @param out - The dual quaternion to store the result in.
+	 * Create a dual quaternion from the given translation.
+	 * @param t - The translation vector.
 	 * @returns The dual quaternion.
 	 */
-	public static fromMatrix4<T extends DualQuaternionLike = DualQuaternion>(
-		matrix: Matrix4Like,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return fromMatrix4(matrix, out);
+	public static fromTranslation(t: Vector3Like): DualQuaternion {
+		return fromTranslation(t, new DualQuaternion());
 	}
 
 	/**
-	 * Create an identity dual quaternion.
-	 * @see {@link https://en.wikipedia.org/wiki/Dual_quaternion | Dual quaternion}
+	 * Create a dual quaternion with the given values.
+	 * @param x1 - The first real component.
+	 * @param y1 - The second real component.
+	 * @param z1 - The third real component.
+	 * @param w1 - The fourth real component.
+	 * @param x2 - The first dual component.
+	 * @param y2 - The second dual component.
+	 * @param z2 - The third dual component.
+	 * @param w2 - The fourth dual component.
+	 * @returns A new dual quaternion.
 	 */
-	public constructor() {
-		super(8);
-		this[3] = 1;
+	public static fromValues(
+		x1: number,
+		y1: number,
+		z1: number,
+		w1: number,
+		x2: number,
+		y2: number,
+		z2: number,
+		w2: number
+	): DualQuaternion {
+		return fromValues(x1, y1, z1, w1, x2, y2, z2, w2, new DualQuaternion());
 	}
 
-	/** The first real component of this dual quaternion. */
-	public 0: number;
-
-	/** The second real component of this dual quaternion. */
-	public 1: number;
-
-	/** The third real component of this dual quaternion. */
-	public 2: number;
-
-	/** The fourth real component of this dual quaternion. */
-	public 3: number;
-
-	/** The first dual component of this dual quaternion. */
-	public 4: number;
-
-	/** The second dual component of this dual quaternion. */
-	public 5: number;
+	/**
+	 * Add another dual quaternion to this one.
+	 * @param dq - The other dual quaternion.
+	 * @returns The sum.
+	 */
+	public add(dq: DualQuaternionLike): DualQuaternion {
+		return add(this, dq, new DualQuaternion());
+	}
 
-	/** The third dual component of this dual quaternion. */
-	public 6: number;
+	/**
+	 * Copy the values from this dual quaternion to another one.
+	 * @returns The copy.
+	 */
+	public clone(): DualQuaternion {
+		return copy(this, new DualQuaternion());
+	}
 
-	/** The fourth dual component of this dual quaternion. */
-	public 7: number;
+	/**
+	 * Calculate the conjugate of this dual quaternion. If this dual quaternion is normalized, this is equivalent to its inverse and faster to calculate.
+	 * @returns The conjugate.
+	 */
+	public conjugate(): DualQuaternion {
+		return conjugate(this, new DualQuaternion());
+	}
 
 	/**
 	 * Copy the values from another dual quaternion to this one.
@@ -1133,288 +1165,188 @@ export default class DualQuaternion
 	}
 
 	/**
-	 * Copy the values from this dual quaternion to another one.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The copy.
-	 */
-	public clone<T extends DualQuaternionLike = DualQuaternion>(
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return copy(this, out);
-	}
-
-	/**
-	 * Set this dual quaternion to the identity dual quaternion.
-	 * @returns The identity dual quaternion.
+	 * Calculate the dot product of this and another dual quaternion.
+	 * @param dq - The other dual quaternion.
+	 * @returns The dot product.
+	 * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
 	 */
-	public identity(): this {
-		return identity(this);
+	public dot(dq: DualQuaternionLike): number {
+		return dot(this, dq);
 	}
 
 	/**
-	 * Get the real part of this dual quaternion.
-	 * @param out - The quaternion to store the result in.
-	 * @returns The real part.
+	 * Determine whether or not this dual quaternion is roughly equivalent to another.
+	 * @param dq - The other dual quaternion.
+	 * @returns Whether or not the dual quaternions are equivalent.
 	 */
-	public getReal<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return getReal(this, out);
+	public equals(dq: DualQuaternionLike): boolean {
+		return equals(this, dq);
 	}
 
 	/**
-	 * Set the real part of this dual quaternion.
-	 * @param q - The quaternion.
+	 * Determine whether or not this dual quaternion is exactly equivalent to another.
+	 * @param dq - The other dual quaternion.
+	 * @returns Whether or not the dual quaternions are equivalent.
 	 */
-	public setReal(q: QuaternionLike): void {
-		setReal(q, this);
+	public exactEquals(dq: DualQuaternionLike): boolean {
+		return exactEquals(this, dq);
 	}
 
 	/**
 	 * Get the dual part of this dual quaternion.
-	 * @param out - The quaternion to store the result in.
 	 * @returns The dual part.
 	 */
-	public getDual<T extends QuaternionLike = Quaternion>(
-		out: T = new Quaternion() as Quaternion & T
-	): T {
-		return getDual(this, out);
+	public getDual(): Quaternion {
+		return getDual(this, new Quaternion());
 	}
 
 	/**
-	 * Set the real part of this dual quaternion.
-	 * @param q - The quaternion.
+	 * Get the real part of this dual quaternion.
+	 * @returns The real part.
 	 */
-	public setDual(q: QuaternionLike): void {
-		setDual(q, this);
+	public getReal(): Quaternion {
+		return getReal(this, new Quaternion());
 	}
 
 	/**
 	 * Get the translation of this normalized dual quaternion.
-	 * @param out - The vector to store the result in.
 	 * @returns The translation.
 	 */
-	public getTranslation<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return getTranslation(this, out);
+	public getTranslation(): Vector3 {
+		return getTranslation(this, new Vector3());
 	}
 
 	/**
-	 * Translate this dual quaternion by the given vector.
-	 * @param v - The vector.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The translated dual quaternion.
-	 */
-	public translate<T extends DualQuaternionLike = DualQuaternion>(
-		v: Vector3Like,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return translate(this, v, out);
-	}
-
-	/**
-	 * Rotate this dual quaternion around the X-axis.
-	 * @param r - The angle to rotate by in radians.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The rotated dual quaternion.
+	 * Set this dual quaternion to the identity dual quaternion.
+	 * @returns The identity dual quaternion.
 	 */
-	public rotateX<T extends DualQuaternionLike = DualQuaternion>(
-		r: number,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return rotateX(this, r, out);
+	public identity(): this {
+		return identity(this);
 	}
 
 	/**
-	 * Rotate this dual quaternion around the Y-axis.
-	 * @param r - The angle to rotate by in radians.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The rotated dual quaternion.
+	 * Calculate the inverse of this dual quaternion. If this dual quaternion is normalized, the conjugate is equivalent and faster to calculate.
+	 * @returns The inverse.
 	 */
-	public rotateY<T extends DualQuaternionLike = DualQuaternion>(
-		r: number,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return rotateY(this, r, out);
+	public invert(): DualQuaternion {
+		return invert(this, new DualQuaternion());
 	}
 
 	/**
-	 * Rotate this dual quaternion around the Z-axis.
-	 * @param r - The angle to rotate by in radians.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The rotated dual quaternion.
+	 * Perform a linear interpolation between this and another dual quaternion.
+	 * @param dq - The other dual quaternion.
+	 * @param t - The interpolation amount in `[0,1]`.
+	 * @returns The interpolated value.
 	 */
-	public rotateZ<T extends DualQuaternionLike = DualQuaternion>(
-		r: number,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return rotateZ(this, r, out);
+	public lerp(dq: DualQuaternionLike, t: number): DualQuaternion {
+		return lerp(this, dq, t, new DualQuaternion());
 	}
 
 	/**
-	 * Rotate this dual quaternion by a quaternion (using the quaternion as the multiplicand).
-	 * @param q - The quaternion.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The rotated dual quaternion.
-	 * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
+	 * Multiply this dual quaternion by another one.
+	 * @param dq - The other dual quaternion.
+	 * @returns The product.
 	 */
-	public rotateByQuaternionAppend<
-		T extends DualQuaternionLike = DualQuaternion
-	>(q: QuaternionLike, out: T = new DualQuaternion() as DualQuaternion & T): T {
-		return rotateByQuaternionAppend(this, q, out);
+	public multiply(dq: DualQuaternionLike): DualQuaternion {
+		return multiply(this, dq, new DualQuaternion());
 	}
 
 	/**
-	 * Rotate this dual quaternion by a quaternion (using the quaternion as the multiplier).
-	 * @param q - The quaternion.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The rotated dual quaternion.
-	 * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
+	 * Normalize this dual quaternion.
+	 * @returns The normalized dual quaternion.
 	 */
-	public rotateByQuaternionPrepend<
-		T extends DualQuaternionLike = DualQuaternion
-	>(q: QuaternionLike, out: T = new DualQuaternion() as DualQuaternion & T): T {
-		return rotateByQuaternionPrepend(q, this, out);
+	public normalize(): DualQuaternion {
+		return normalize(this, new DualQuaternion());
 	}
 
 	/**
 	 * Rotate this dual quaternion around an axis.
 	 * @param axis - The axis.
 	 * @param r - The angle of the rotation in radians.
-	 * @param out - The dual quaternion to store the result in.
 	 * @returns A normalized dual quaternion.
 	 */
-	public rotateAroundAxis<T extends DualQuaternionLike = DualQuaternion>(
-		axis: Vector3Like,
-		r: number,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return rotateAroundAxis(this, axis, r, out);
-	}
-
-	/**
-	 * Add another dual quaternion to this one.
-	 * @param dq - The other dual quaternion.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The sum.
-	 */
-	public add<T extends DualQuaternionLike = DualQuaternion>(
-		dq: DualQuaternionLike,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return add(this, dq, out);
+	public rotateAroundAxis(axis: Vector3Like, r: number): DualQuaternion {
+		return rotateAroundAxis(this, axis, r, new DualQuaternion());
 	}
 
 	/**
-	 * Multiply this dual quaternion by another one.
-	 * @param dq - The other dual quaternion.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The product.
+	 * Rotate this dual quaternion by a quaternion (using the quaternion as the multiplicand).
+	 * @param q - The quaternion.
+	 * @returns The rotated dual quaternion.
+	 * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
 	 */
-	public multiply<T extends DualQuaternionLike = DualQuaternion>(
-		dq: DualQuaternionLike,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return multiply(this, dq, out);
+	public rotateByQuaternionAppend(q: QuaternionLike): DualQuaternion {
+		return rotateByQuaternionAppend(this, q, new DualQuaternion());
 	}
 
 	/**
-	 * Multiply this dual quaternion by a scalar.
-	 * @param s - The scalar.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The product.
+	 * Rotate this dual quaternion by a quaternion (using the quaternion as the multiplier).
+	 * @param q - The quaternion.
+	 * @returns The rotated dual quaternion.
+	 * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
 	 */
-	public scale<T extends DualQuaternionLike = DualQuaternion>(
-		s: number,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return scale(this, s, out);
+	public rotateByQuaternionPrepend(q: QuaternionLike): DualQuaternion {
+		return rotateByQuaternionPrepend(q, this, new DualQuaternion());
 	}
 
 	/**
-	 * Calculate the dot product of this and another dual quaternion.
-	 * @param dq - The other dual quaternion.
-	 * @returns The dot product.
-	 * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
+	 * Rotate this dual quaternion around the X-axis.
+	 * @param r - The angle to rotate by in radians.
+	 * @returns The rotated dual quaternion.
 	 */
-	public dot(dq: DualQuaternionLike): number {
-		return dot(this, dq);
+	public rotateX(r: number): DualQuaternion {
+		return rotateX(this, r, new DualQuaternion());
 	}
 
 	/**
-	 * Perform a linear interpolation between this and another dual quaternion.
-	 * @param dq - The other dual quaternion.
-	 * @param t - The interpolation amount in `[0,1]`.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The interpolated value.
+	 * Rotate this dual quaternion around the Y-axis.
+	 * @param r - The angle to rotate by in radians.
+	 * @returns The rotated dual quaternion.
 	 */
-	public lerp<T extends DualQuaternionLike = DualQuaternion>(
-		dq: DualQuaternionLike,
-		t: number,
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return lerp(this, dq, t, out);
+	public rotateY(r: number): DualQuaternion {
+		return rotateY(this, r, new DualQuaternion());
 	}
 
 	/**
-	 * Calculate the inverse of this dual quaternion. If this dual quaternion is normalized, the conjugate is equivalent and faster to calculate.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The inverse.
+	 * Rotate this dual quaternion around the Z-axis.
+	 * @param r - The angle to rotate by in radians.
+	 * @returns The rotated dual quaternion.
 	 */
-	public invert<T extends DualQuaternionLike = DualQuaternion>(
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return invert(this, out);
+	public rotateZ(r: number): DualQuaternion {
+		return rotateZ(this, r, new DualQuaternion());
 	}
 
 	/**
-	 * Calculate the conjugate of this dual quaternion. If this dual quaternion is normalized, this is equivalent to its inverse and faster to calculate.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The conjugate.
+	 * Multiply this dual quaternion by a scalar.
+	 * @param s - The scalar.
+	 * @returns The product.
 	 */
-	public conjugate<T extends DualQuaternionLike = DualQuaternion>(
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return conjugate(this, out);
-	}
-
-	/** Get the magnitude (length) of this dual quaternion. */
-	public get magnitude(): number {
-		return getMagnitude(this);
-	}
-
-	/** Get the squared magnitude (length) of this dual quaternion. */
-	public get squaredMagnitude(): number {
-		return getSquaredMagnitude(this);
+	public scale(s: number): DualQuaternion {
+		return scale(this, s, new DualQuaternion());
 	}
 
 	/**
-	 * Normalize this dual quaternion.
-	 * @param out - The dual quaternion to store the result in.
-	 * @returns The normalized dual quaternion.
+	 * Set the real part of this dual quaternion.
+	 * @param q - The quaternion.
 	 */
-	public normalize<T extends DualQuaternionLike = DualQuaternion>(
-		out: T = new DualQuaternion() as DualQuaternion & T
-	): T {
-		return normalize(this, out);
+	public setDual(q: QuaternionLike): void {
+		setDual(q, this);
 	}
 
 	/**
-	 * Determine whether or not this dual quaternion is exactly equivalent to another.
-	 * @param dq - The other dual quaternion.
-	 * @returns Whether or not the dual quaternions are equivalent.
+	 * Set the real part of this dual quaternion.
+	 * @param q - The quaternion.
 	 */
-	public exactEquals(dq: DualQuaternionLike): boolean {
-		return exactEquals(this, dq);
+	public setReal(q: QuaternionLike): void {
+		setReal(q, this);
 	}
 
 	/**
-	 * Determine whether or not this dual quaternion is roughly equivalent to another.
-	 * @param dq - The other dual quaternion.
-	 * @returns Whether or not the dual quaternions are equivalent.
+	 * Translate this dual quaternion by the given vector.
+	 * @param v - The vector.
+	 * @returns The translated dual quaternion.
 	 */
-	public equals(dq: DualQuaternionLike): boolean {
-		return equals(this, dq);
+	public translate(v: Vector3Like): DualQuaternion {
+		return translate(this, v, new DualQuaternion());
 	}
 }