@lakuna/umath 1.5.0 → 3.0.0

package/dist/linalg/DualQuaternion.js

@@ -1,17 +1,17 @@
+import approxRelative from "../algorithms/approxRelative.js";
+import epsilon from "../utility/epsilon.js";
 import { getScaling as matrix4GetScaling } from "./Matrix4.js";
 import Quaternion, { rotateX as quaternionRotateX, rotateY as quaternionRotateY, rotateZ as quaternionRotateZ } from "./Quaternion.js";
 import Vector3, { createVector3Like, fromValues as vector3FromValues } from "./Vector3.js";
 import { copy as vector4Copy, dot as vector4Dot, fromValues as vector4FromValues, getMagnitude as vector4GetMagnitude, getSquaredMagnitude as vector4GetSquaredMagnitude } from "./Vector4.js";
-import approxRelative from "../algorithms/approxRelative.js";
-import epsilon from "../utility/epsilon.js";
 /**
  * Create a dual quaternion-like object.
  * @returns A dual quaternion-like object.
  * @public
  */
-export const createDualQuaternionLike = () => {
-    return new Float32Array(8);
-};
+export const createDualQuaternionLike = () => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+new Float32Array(8);
 /**
  * Create a dual quaternion with the given values.
  * @param x1 - The first real component.
@@ -103,13 +103,13 @@ export const fromMatrix4 = (matrix, out) => {
     const sm32 = matrix[9] * is2;
     const sm33 = matrix[10] * is3;
     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;
@@ -404,7 +404,7 @@ export const rotateAroundAxis = (dualQuaternion, axis, radians, out) => {
     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;
     const s = Math.sin(r);
     const bx = (s * ax) / axisLength;
@@ -618,83 +618,116 @@ export const equals = (a, b) => approxRelative(a[0], b[0]) &&
  * @public
  */
 export default class DualQuaternion extends Float32Array {
+    /** The first real component of this dual quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    0;
+    /** The second real component of this dual quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    1;
+    /** The third real component of this dual quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    2;
+    /** The fourth real component of this dual quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    3;
+    /** The first dual component of this dual quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    4;
+    /** The second dual component of this dual quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    5;
+    /** The third dual component of this dual quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    6;
+    /** The fourth dual component of this dual quaternion. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    7;
+    /** Get the magnitude (length) of this dual quaternion. */
+    get magnitude() {
+        return getMagnitude(this);
+    }
+    /** Get the squared magnitude (length) of this dual quaternion. */
+    get squaredMagnitude() {
+        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}
+     */
+    constructor() {
+        super(8);
+        this[3] = 1;
+    }
+    /**
+     * Create a dual quaternion from the given four-by-four matrix.
+     * @param matrix - The matrix.
+     * @returns The dual quaternion.
+     */
+    static fromMatrix4(matrix) {
+        return fromMatrix4(matrix, new DualQuaternion());
+    }
+    /**
+     * Create a dual quaternion from the given rotation.
+     * @param q - The rotation quaternion.
+     * @returns The dual quaternion.
      */
-    static fromValues(x1, y1, z1, w1, x2, y2, z2, w2, out = new DualQuaternion()) {
-        return fromValues(x1, y1, z1, w1, x2, y2, z2, w2, out);
+    static fromRotation(q) {
+        return fromRotation(q, new DualQuaternion());
     }
     /**
      * 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.
      * @returns The dual quaternion.
      */
-    static fromRotationTranslation(q, t, out = new DualQuaternion()) {
-        return fromRotationTranslation(q, t, out);
+    static fromRotationTranslation(q, t) {
+        return fromRotationTranslation(q, t, 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.
      * @returns The dual quaternion.
      */
-    static fromTranslation(t, out = new DualQuaternion()) {
-        return fromTranslation(t, out);
+    static fromTranslation(t) {
+        return fromTranslation(t, new DualQuaternion());
     }
     /**
-     * Create a dual quaternion from the given rotation.
-     * @param q - The rotation quaternion.
-     * @param out - The dual quaternion to store the result in.
-     * @returns The 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.
      */
-    static fromRotation(q, out = new DualQuaternion()) {
-        return fromRotation(q, out);
+    static fromValues(x1, y1, z1, w1, x2, y2, z2, w2) {
+        return fromValues(x1, y1, z1, w1, x2, y2, z2, w2, 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.
-     * @returns The dual quaternion.
+     * Add another dual quaternion to this one.
+     * @param dq - The other dual quaternion.
+     * @returns The sum.
      */
-    static fromMatrix4(matrix, out = new DualQuaternion()) {
-        return fromMatrix4(matrix, out);
+    add(dq) {
+        return add(this, dq, new DualQuaternion());
     }
     /**
-     * Create an identity dual quaternion.
-     * @see {@link https://en.wikipedia.org/wiki/Dual_quaternion | Dual quaternion}
+     * Copy the values from this dual quaternion to another one.
+     * @returns The copy.
      */
-    constructor() {
-        super(8);
-        this[3] = 1;
+    clone() {
+        return copy(this, 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.
+     * @returns The conjugate.
+     */
+    conjugate() {
+        return conjugate(this, new DualQuaternion());
     }
-    /** The first real component of this dual quaternion. */
-    0;
-    /** The second real component of this dual quaternion. */
-    1;
-    /** The third real component of this dual quaternion. */
-    2;
-    /** The fourth real component of this dual quaternion. */
-    3;
-    /** The first dual component of this dual quaternion. */
-    4;
-    /** The second dual component of this dual quaternion. */
-    5;
-    /** The third dual component of this dual quaternion. */
-    6;
-    /** The fourth dual component of this dual quaternion. */
-    7;
     /**
      * Copy the values from another dual quaternion to this one.
      * @param dualQuaternion - The dual quaternion to copy.
@@ -704,217 +737,169 @@ export default class DualQuaternion extends Float32Array {
         return copy(dualQuaternion, this);
     }
     /**
-     * Copy the values from this dual quaternion to another one.
-     * @param out - The dual quaternion to store the result in.
-     * @returns The copy.
-     */
-    clone(out = new DualQuaternion()) {
-        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}
      */
-    identity() {
-        return identity(this);
+    dot(dq) {
+        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.
      */
-    getReal(out = new Quaternion()) {
-        return getReal(this, out);
+    equals(dq) {
+        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.
      */
-    setReal(q) {
-        setReal(q, this);
+    exactEquals(dq) {
+        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.
      */
-    getDual(out = new Quaternion()) {
-        return getDual(this, out);
+    getDual() {
+        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.
      */
-    setDual(q) {
-        setDual(q, this);
+    getReal() {
+        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.
      */
-    getTranslation(out = new Vector3()) {
-        return getTranslation(this, out);
+    getTranslation() {
+        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.
+     * Set this dual quaternion to the identity dual quaternion.
+     * @returns The identity dual quaternion.
      */
-    translate(v, out = new DualQuaternion()) {
-        return translate(this, v, out);
+    identity() {
+        return identity(this);
     }
     /**
-     * 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.
+     * Calculate the inverse of this dual quaternion. If this dual quaternion is normalized, the conjugate is equivalent and faster to calculate.
+     * @returns The inverse.
      */
-    rotateX(r, out = new DualQuaternion()) {
-        return rotateX(this, r, out);
+    invert() {
+        return invert(this, new DualQuaternion());
     }
     /**
-     * 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.
+     * 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.
      */
-    rotateY(r, out = new DualQuaternion()) {
-        return rotateY(this, r, out);
+    lerp(dq, t) {
+        return lerp(this, dq, t, 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.
+     * Multiply this dual quaternion by another one.
+     * @param dq - The other dual quaternion.
+     * @returns The product.
+     */
+    multiply(dq) {
+        return multiply(this, dq, new DualQuaternion());
+    }
+    /**
+     * Normalize this dual quaternion.
+     * @returns The normalized dual quaternion.
      */
-    rotateZ(r, out = new DualQuaternion()) {
-        return rotateZ(this, r, out);
+    normalize() {
+        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.
+     * @returns A normalized dual quaternion.
+     */
+    rotateAroundAxis(axis, r) {
+        return rotateAroundAxis(this, axis, r, 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}
      */
-    rotateByQuaternionAppend(q, out = new DualQuaternion()) {
-        return rotateByQuaternionAppend(this, q, out);
+    rotateByQuaternionAppend(q) {
+        return rotateByQuaternionAppend(this, q, 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}
      */
-    rotateByQuaternionPrepend(q, out = new DualQuaternion()) {
-        return rotateByQuaternionPrepend(q, this, out);
+    rotateByQuaternionPrepend(q) {
+        return rotateByQuaternionPrepend(q, 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.
+     * Rotate this dual quaternion around the X-axis.
+     * @param r - The angle to rotate by in radians.
+     * @returns The rotated dual quaternion.
      */
-    rotateAroundAxis(axis, r, out = new DualQuaternion()) {
-        return rotateAroundAxis(this, axis, r, out);
+    rotateX(r) {
+        return rotateX(this, r, new DualQuaternion());
     }
     /**
-     * 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.
+     * Rotate this dual quaternion around the Y-axis.
+     * @param r - The angle to rotate by in radians.
+     * @returns The rotated dual quaternion.
      */
-    add(dq, out = new DualQuaternion()) {
-        return add(this, dq, out);
+    rotateY(r) {
+        return rotateY(this, 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 around the Z-axis.
+     * @param r - The angle to rotate by in radians.
+     * @returns The rotated dual quaternion.
      */
-    multiply(dq, out = new DualQuaternion()) {
-        return multiply(this, dq, out);
+    rotateZ(r) {
+        return rotateZ(this, r, 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.
      */
-    scale(s, out = new DualQuaternion()) {
-        return scale(this, s, out);
-    }
-    /**
-     * 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}
-     */
-    dot(dq) {
-        return dot(this, dq);
-    }
-    /**
-     * 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.
-     */
-    lerp(dq, t, out = new DualQuaternion()) {
-        return lerp(this, dq, t, out);
-    }
-    /**
-     * 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.
-     */
-    invert(out = new DualQuaternion()) {
-        return invert(this, out);
+    scale(s) {
+        return scale(this, s, 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.
-     */
-    conjugate(out = new DualQuaternion()) {
-        return conjugate(this, out);
-    }
-    /** Get the magnitude (length) of this dual quaternion. */
-    get magnitude() {
-        return getMagnitude(this);
-    }
-    /** Get the squared magnitude (length) of this dual quaternion. */
-    get squaredMagnitude() {
-        return getSquaredMagnitude(this);
-    }
-    /**
-     * 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.
      */
-    normalize(out = new DualQuaternion()) {
-        return normalize(this, out);
+    setDual(q) {
+        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.
      */
-    exactEquals(dq) {
-        return exactEquals(this, dq);
+    setReal(q) {
+        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.
      */
-    equals(dq) {
-        return equals(this, dq);
+    translate(v) {
+        return translate(this, v, new DualQuaternion());
     }
 }
 //# sourceMappingURL=DualQuaternion.js.map