@lakuna/umath 1.5.0 → 3.0.0

package/dist/linalg/Vector3.js

@@ -4,9 +4,9 @@ import approxRelative from "../algorithms/approxRelative.js";
  * @returns A 3x1 vector-like object.
  * @public
  */
-export const createVector3Like = () => {
-    return new Float32Array(3);
-};
+export const createVector3Like = () => 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion
+new Float32Array(3);
 /**
  * Create a vector with the given values.
  * @param x - The first component.
@@ -170,12 +170,7 @@ export const scaleAndAdd = (a, b, scalar, out) => fromValues(a[0] + b[0] * scala
  * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
  * @public
  */
-export const distance = (a, b) => {
-    const x = b[0] - a[0];
-    const y = b[1] - a[1];
-    const z = b[2] - a[2];
-    return Math.sqrt(x * x + y * y + z * z); // `Math.hypot` is slower.
-};
+export const distance = (a, b) => Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
 /**
  * Calculate the squared Euclidean distance between this vector and another.
  * @param a - The first vector.
@@ -196,12 +191,7 @@ export const squaredDistance = (a, b) => {
  * @returns The magnitude.
  * @public
  */
-export const getMagnitude = (vector) => {
-    const x = vector[0];
-    const y = vector[1];
-    const z = vector[2];
-    return Math.sqrt(x * x + y * y + z * z); // `Math.hypot` is slower.
-};
+export const getMagnitude = (vector) => Math.hypot(vector[0], vector[1], vector[2]);
 /**
  * Calculate the squared magnitude (length) of a vector.
  * @param vector - The vector.
@@ -414,15 +404,7 @@ export const rotateZ = (vector, origin, r, out) => {
  * @public
  */
 export const angle = (a, b) => {
-    const ax = a[0];
-    const ay = a[1];
-    const az = a[2];
-    const bx = b[0];
-    const by = b[1];
-    const bz = b[2];
-    // `Math.hypot` is slower.
-    const mag = Math.sqrt(ax * ax + ay * ay + az * az) *
-        Math.sqrt(bx * bx + by * by + bz * bz);
+    const mag = Math.hypot(a[0], a[1], a[2]) * Math.hypot(b[0], b[1], b[2]);
     return Math.acos(Math.min(Math.max(mag && dot(a, b) / mag, -1), 1));
 };
 /**
@@ -503,62 +485,94 @@ export const transformQuaternion = (vector, quaternion, out) => {
  * @public
  */
 export default class Vector3 extends Float32Array {
+    /** The first component of this vector. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    0;
+    /** The second component of this vector. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    1;
+    /** The third component of this vector. */
+    // eslint-disable-next-line @typescript-eslint/naming-convention
+    2;
+    /** The magnitude (length) of this vector. */
+    get magnitude() {
+        return getMagnitude(this);
+    }
+    set magnitude(value) {
+        scale(normalize(this, this), value, this);
+    }
+    /** The squared magnitude (length) of this vector. */
+    get squaredMagnitude() {
+        return getSquaredMagnitude(this);
+    }
+    set squaredMagnitude(value) {
+        this.magnitude = Math.sqrt(value);
+    }
+    /**
+     * Create a three-dimensional zero vector.
+     * @see {@link https://en.wikipedia.org/wiki/Euclidean_vector | Euclidean vector}
+     */
+    constructor() {
+        super(3);
+    }
     /**
      * Create a vector with the given values.
      * @param x - The first component.
      * @param y - The second component.
      * @param z - The third component.
-     * @param out - The vector to store the result in.
      * @returns A new vector.
      */
-    static fromValues(x, y, z, out = new Vector3()) {
-        return fromValues(x, y, z, out);
+    static fromValues(x, y, z) {
+        return fromValues(x, y, z, new Vector3());
     }
     /**
-     * Create a three-dimensional zero vector.
-     * @see {@link https://en.wikipedia.org/wiki/Euclidean_vector | Euclidean vector}
+     * Absolutize the components of this vector.
+     * @returns The absolutized vector.
      */
-    constructor() {
-        super(3);
+    abs() {
+        return abs(this, new Vector3());
     }
-    /** The first component of this vector. */
-    0;
-    /** The second component of this vector. */
-    1;
-    /** The third component of this vector. */
-    2;
     /**
-     * Determine whether or not this vector is roughly equivalent to another.
+     * Add two vectors of the same size.
      * @param vector - The other vector.
-     * @returns Whether or not the vectors are equivalent.
+     * @returns The sum of the vectors.
      */
-    equals(vector) {
-        return equals(this, vector);
+    add(vector) {
+        return add(this, vector, new Vector3());
     }
     /**
-     * Determine whether or not this vector is exactly equivalent to another.
+     * Get the angle from this vector to another in radians.
      * @param vector - The other vector.
-     * @returns Whether or not the vectors are equivalent.
+     * @returns The angular distance from this vector to the other.
      */
-    exactEquals(vector) {
-        return exactEquals(this, vector);
+    angle(vector) {
+        return angle(this, vector);
     }
     /**
-     * Add two vectors of the same size.
-     * @param vector - The other vector.
-     * @param out - The vector to store the result in.
-     * @returns The sum of the vectors.
+     * Perform a Bézier interpolation with two control points between this vector and another.
+     * @param a - The first control point.
+     * @param b - The second control point.
+     * @param end - The other vector.
+     * @param t - The interpolation amount in the range `[0,1]`.
+     * @returns The interpolated vector.
+     * @see {@link https://en.wikipedia.org/wiki/B%C3%A9zier_curve | Bézier curve}
+     */
+    bezier(a, b, end, t) {
+        return bezier(this, a, b, end, t, new Vector3());
+    }
+    /**
+     * Round up the components of this vector.
+     * @returns The rounded vector.
      */
-    add(vector, out = new Vector3()) {
-        return add(this, vector, out);
+    ceil() {
+        return ceil(this, new Vector3());
     }
     /**
      * Copy the values from this vector to another one.
-     * @param out - The vector to store the result in.
      * @returns The copy.
      */
-    clone(out = new Vector3()) {
-        return copy(this, out);
+    clone() {
+        return copy(this, new Vector3());
     }
     /**
      * Copy the values of another vector into this one.
@@ -569,190 +583,138 @@ export default class Vector3 extends Float32Array {
         return copy(vector, this);
     }
     /**
-     * Multiply this vector by another.
+     * Calculate the cross product of this and another vector.
      * @param vector - The other vector.
-     * @param out - The vector to store the result in.
-     * @returns The product of the vectors.
+     * @returns The cross product.
+     * @see {@link https://en.wikipedia.org/wiki/Cross_product | Cross product}
+     */
+    cross(vector) {
+        return cross(this, vector, new Vector3());
+    }
+    /**
+     * Calculate the Euclidean distance between this vector and another.
+     * @param vector - The other vector.
+     * @returns The distance.
+     * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
      */
-    multiply(vector, out = new Vector3()) {
-        return multiply(this, vector, out);
+    distance(vector) {
+        return distance(this, vector);
     }
     /**
      * Divide this vector by another.
      * @param vector - The other vector.
-     * @param out - The vector to store the result in.
      * @returns The quotient of the vectors.
      */
-    divide(vector, out = new Vector3()) {
-        return divide(this, vector, out);
+    divide(vector) {
+        return divide(this, vector, new Vector3());
     }
     /**
-     * Subtract another vector from this one.
+     * Calculate the dot product of this and another vector.
      * @param vector - The other vector.
-     * @param out - The vector to store the result in.
-     * @returns The difference between the vectors.
+     * @returns The dot product.
+     * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
      */
-    subtract(vector, out = new Vector3()) {
-        return subtract(this, vector, out);
+    dot(vector) {
+        return dot(this, vector);
     }
     /**
-     * Absolutize the components of this vector.
-     * @param out - The vector to store the result in.
-     * @returns The absolutized vector.
+     * Determine whether or not this vector is roughly equivalent to another.
+     * @param vector - The other vector.
+     * @returns Whether or not the vectors are equivalent.
      */
-    abs(out = new Vector3()) {
-        return abs(this, out);
+    equals(vector) {
+        return equals(this, vector);
     }
     /**
-     * Round up the components of this vector.
-     * @param out - The vector to store the result in.
-     * @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.
      */
-    ceil(out = new Vector3()) {
-        return ceil(this, out);
+    exactEquals(vector) {
+        return exactEquals(this, vector);
     }
     /**
      * Round down the components of this vector.
-     * @param out - The vector to store the result in.
      * @returns The rounded vector.
      */
-    floor(out = new Vector3()) {
-        return floor(this, out);
+    floor() {
+        return floor(this, new Vector3());
     }
     /**
-     * Round the components of this vector.
-     * @param out - The vector to store the result in.
-     * @returns The rounded vector.
+     * Perform a Hermite interpolation with two control points between this vector and another.
+     * @param a - The first control point.
+     * @param b - The second control point.
+     * @param end - The other vector.
+     * @param t - The interpolation amount in the range `[0,1]`.
+     * @returns The interpolated vector.
+     * @see {@link https://en.wikipedia.org/wiki/Hermite_interpolation | Hermite interpolation}
      */
-    round(out = new Vector3()) {
-        return round(this, out);
+    hermite(a, b, end, t) {
+        return hermite(this, a, b, end, t, new Vector3());
     }
     /**
-     * Return the minimum of this and another vector.
-     * @param vector - The other vector.
-     * @param out - The vector to store the result in.
-     * @returns The minimum.
+     * Calculate the multiplicative inverse of the components of this vector.
+     * @returns The inverted vector.
      */
-    min(vector, out = new Vector3()) {
-        return min(this, vector, out);
+    invert() {
+        return invert(this, new Vector3());
     }
     /**
-     * Return the maximum of this and another vector.
+     * Perform a linear interpolation between this and another vector.
      * @param vector - The other vector.
-     * @param out - The vector to store the result in.
-     * @returns The maximum.
-     */
-    max(vector, out = new Vector3()) {
-        return max(this, vector, out);
-    }
-    /**
-     * Raise each component of this vector to the given power.
-     * @param scalar - The exponent (power) to raise each component to.
-     * @param out - The vector to store the result in.
-     * @returns The power (result of the exponentiation).
-     */
-    pow(scalar, out = new Vector3()) {
-        return pow(this, scalar, out);
-    }
-    /**
-     * Scale this vector by a scalar.
-     * @param scalar - The scalar.
-     * @param out - The vector to store the result in.
-     * @returns The scaled vector.
+     * @param t - The interpolation amount (in `[0,1]`).
+     * @returns The interpolated vector.
+     * @see {@link https://en.wikipedia.org/wiki/Linear_interpolation | Linear interpolation}
      */
-    scale(scalar, out = new Vector3()) {
-        return scale(this, scalar, out);
+    lerp(vector, t) {
+        return lerp(this, vector, t, new Vector3());
     }
     /**
-     * Add another vector to this one after scaling the other by a scalar.
+     * Return the maximum of this and another vector.
      * @param vector - The other vector.
-     * @param scalar - The scalar.
-     * @param out - The vector to store the result in.
-     * @returns The sum.
+     * @returns The maximum.
      */
-    scaleAndAdd(vector, scalar, out = new Vector3()) {
-        return scaleAndAdd(this, vector, scalar, out);
+    max(vector) {
+        return max(this, vector, new Vector3());
     }
     /**
-     * Calculate the Euclidean distance between this vector and another.
+     * Return the minimum of this and another vector.
      * @param vector - The other vector.
-     * @returns The distance.
-     * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
+     * @returns The minimum.
      */
-    distance(vector) {
-        return distance(this, vector);
+    min(vector) {
+        return min(this, vector, new Vector3());
     }
     /**
-     * Calculate the squared Euclidean distance between this vector and another.
+     * Multiply this vector by another.
      * @param vector - The other vector.
-     * @returns The squared distance.
-     * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
+     * @returns The product of the vectors.
      */
-    squaredDistance(vector) {
-        return squaredDistance(this, vector);
-    }
-    /** Get the magnitude (length) of this vector. */
-    get magnitude() {
-        return getMagnitude(this);
-    }
-    /** Get the squared magnitude (length) of this vector. */
-    get squaredMagnitude() {
-        return getSquaredMagnitude(this);
+    multiply(vector) {
+        return multiply(this, vector, new Vector3());
     }
     /**
      * Negate this vector.
-     * @param out - The vector to store the result in.
      * @returns The negated vector.
      */
-    negate(out = new Vector3()) {
-        return negate(this, out);
-    }
-    /**
-     * Calculate the multiplicative inverse of the components of this vector.
-     * @param out - The vector to store the result in.
-     * @returns The inverted vector.
-     */
-    invert(out = new Vector3()) {
-        return invert(this, out);
+    negate() {
+        return negate(this, new Vector3());
     }
     /**
      * Normalize this vector.
-     * @param out - The vector to store the result in.
      * @returns The normalized vector.
      * @see {@link https://en.wikipedia.org/wiki/Unit_vector | Unit vector}
      */
-    normalize(out = new Vector3()) {
-        return normalize(this, out);
-    }
-    /**
-     * 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}
-     */
-    dot(vector) {
-        return dot(this, vector);
-    }
-    /**
-     * Calculate the cross product of this and another vector.
-     * @param vector - The other vector.
-     * @param out - The vector to store the result in.
-     * @returns The cross product.
-     * @see {@link https://en.wikipedia.org/wiki/Cross_product | Cross product}
-     */
-    cross(vector, out = new Vector3()) {
-        return cross(this, vector, out);
+    normalize() {
+        return normalize(this, new Vector3());
     }
     /**
-     * Perform a linear interpolation between this and another vector.
-     * @param vector - The other vector.
-     * @param t - The interpolation amount (in `[0,1]`).
-     * @param out - The vector to store the result in.
-     * @returns The interpolated vector.
-     * @see {@link https://en.wikipedia.org/wiki/Linear_interpolation | Linear interpolation}
+     * 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).
      */
-    lerp(vector, t, out = new Vector3()) {
-        return lerp(this, vector, t, out);
+    pow(scalar) {
+        return pow(this, scalar, new Vector3());
     }
     /**
      * Set this vector to a random value with the given magnitude.
@@ -762,104 +724,105 @@ export default class Vector3 extends Float32Array {
     random(magnitude = 1) {
         return random(magnitude, this);
     }
-    /**
-     * Transform this vector by a three-by-three matrix.
-     * @param matrix - The matrix.
-     * @param out - The vector to store the result in.
-     * @returns The transformed vector.
-     */
-    transformMatrix3(matrix, out = new Vector3()) {
-        return transformMatrix3(this, matrix, out);
-    }
-    /**
-     * Transform this vector by a four-by-four matrix.
-     * @param matrix - The matrix.
-     * @param out - The vector to store the result in.
-     * @returns The transformed vector.
-     */
-    transformMatrix4(matrix, out = new Vector3()) {
-        return transformMatrix4(this, matrix, out);
-    }
     /**
      * Rotate this vector around the X-axis.
      * @param origin - The origin of the rotation.
      * @param r - The angle of rotation in radians.
-     * @param out - The vector to store the result in.
      * @returns The rotated vector.
      */
-    rotateX(origin, r, out = new Vector3()) {
-        return rotateX(this, origin, r, out);
+    rotateX(origin, r) {
+        return rotateX(this, origin, r, new Vector3());
     }
     /**
      * Rotate this vector around the Y-axis.
      * @param origin - The origin of the rotation.
      * @param r - The angle of rotation in radians.
-     * @param out - The vector to store the result in.
      * @returns The rotated vector.
      */
-    rotateY(origin, r, out = new Vector3()) {
-        return rotateY(this, origin, r, out);
+    rotateY(origin, r) {
+        return rotateY(this, origin, r, new Vector3());
     }
     /**
      * Rotate this vector around the Z-axis.
      * @param origin - The origin of the rotation.
      * @param r - The angle of rotation in radians.
-     * @param out - The vector to store the result in.
      * @returns The rotated vector.
      */
-    rotateZ(origin, r, out = new Vector3()) {
-        return rotateZ(this, origin, r, out);
+    rotateZ(origin, r) {
+        return rotateZ(this, origin, r, new Vector3());
     }
     /**
-     * Get the angle from this vector to another in radians.
+     * Round the components of this vector.
+     * @returns The rounded vector.
+     */
+    round() {
+        return round(this, new Vector3());
+    }
+    /**
+     * Scale this vector by a scalar.
+     * @param scalar - The scalar.
+     * @returns The scaled vector.
+     */
+    scale(scalar) {
+        return scale(this, scalar, new Vector3());
+    }
+    /**
+     * Add another vector to this one after scaling the other by a scalar.
      * @param vector - The other vector.
-     * @returns The angular distance from this vector to the other.
+     * @param scalar - The scalar.
+     * @returns The sum.
      */
-    angle(vector) {
-        return angle(this, vector);
+    scaleAndAdd(vector, scalar) {
+        return scaleAndAdd(this, vector, scalar, new Vector3());
     }
     /**
-     * Set this to the zero vector.
-     * @returns This vector.
+     * Calculate the squared Euclidean distance between this vector and another.
+     * @param vector - The other vector.
+     * @returns The squared distance.
+     * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
      */
-    zero() {
-        return zero(this);
+    squaredDistance(vector) {
+        return squaredDistance(this, vector);
     }
     /**
-     * Perform a Hermite interpolation with two control points between this vector and another.
-     * @param a - The first control point.
-     * @param b - The second control point.
-     * @param end - The other vector.
-     * @param t - The interpolation amount in the range `[0,1]`.
-     * @param out - The vector to store the result in.
-     * @returns The interpolated vector.
-     * @see {@link https://en.wikipedia.org/wiki/Hermite_interpolation | Hermite interpolation}
+     * Subtract another vector from this one.
+     * @param vector - The other vector.
+     * @returns The difference between the vectors.
      */
-    hermite(a, b, end, t, out = new Vector3()) {
-        return hermite(this, a, b, end, t, out);
+    subtract(vector) {
+        return subtract(this, vector, new Vector3());
     }
     /**
-     * Perform a Bézier interpolation with two control points between this vector and another.
-     * @param a - The first control point.
-     * @param b - The second control point.
-     * @param end - The other vector.
-     * @param t - The interpolation amount in the range `[0,1]`.
-     * @param out - The vector to store the result in.
-     * @returns The interpolated vector.
-     * @see {@link https://en.wikipedia.org/wiki/B%C3%A9zier_curve | Bézier curve}
+     * Transform this vector by a three-by-three matrix.
+     * @param matrix - The matrix.
+     * @returns The transformed vector.
+     */
+    transformMatrix3(matrix) {
+        return transformMatrix3(this, matrix, new Vector3());
+    }
+    /**
+     * Transform this vector by a four-by-four matrix.
+     * @param matrix - The matrix.
+     * @returns The transformed vector.
      */
-    bezier(a, b, end, t, out = new Vector3()) {
-        return bezier(this, a, b, end, t, out);
+    transformMatrix4(matrix) {
+        return transformMatrix4(this, matrix, new Vector3());
     }
     /**
      * Transform this vector by a quaternion.
      * @param quaternion - The quaternion.
-     * @param out - The vector to store the result in.
      * @returns The transformed vector.
      * @see {@link https://en.wikipedia.org/wiki/Quaternion | Quaternion}
      */
-    transformQuaternion(quaternion, out = new Vector3()) {
-        return transformQuaternion(this, quaternion, out);
+    transformQuaternion(quaternion) {
+        return transformQuaternion(this, quaternion, new Vector3());
+    }
+    /**
+     * Set this to the zero vector.
+     * @returns This vector.
+     */
+    zero() {
+        return zero(this);
     }
 }
 //# sourceMappingURL=Vector3.js.map