@lakuna/umath 1.5.0 → 2.0.0

package/src/linalg/Vector3.ts

@@ -302,12 +302,8 @@ export const scaleAndAdd = <T extends Vector3Like>(
  * @see {@link https://en.wikipedia.org/wiki/Euclidean_distance | Euclidean distance}
  * @public
  */
-export const distance = (a: Vector3Like, b: Vector3Like): number => {
-	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: Vector3Like, b: Vector3Like): number =>
+	Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
 
 /**
  * Calculate the squared Euclidean distance between this vector and another.
@@ -330,12 +326,8 @@ export const squaredDistance = (a: Vector3Like, b: Vector3Like): number => {
  * @returns The magnitude.
  * @public
  */
-export const getMagnitude = (vector: Vector3Like): number => {
-	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: Vector3Like): number =>
+	Math.hypot(vector[0], vector[1], vector[2]);
 
 /**
  * Calculate the squared magnitude (length) of a vector.
@@ -655,19 +647,7 @@ export const rotateZ = <T extends Vector3Like>(
  * @public
  */
 export const angle = (a: Vector3Like, b: Vector3Like): number => {
-	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));
 };
 
@@ -802,16 +782,10 @@ export default class Vector3
 	 * @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.
 	 */
-	public static fromValues<T extends Vector3Like = Vector3>(
-		x: number,
-		y: number,
-		z: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return fromValues(x, y, z, out);
+	public static fromValues(x: number, y: number, z: number): Vector3 {
+		return fromValues(x, y, z, new Vector3());
 	}
 
 	/**
@@ -852,25 +826,18 @@ export default class Vector3
 	/**
 	 * 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.
 	 */
-	public add<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return add(this, vector, out);
+	public add(vector: Vector3Like): Vector3 {
+		return add(this, vector, new Vector3());
 	}
 
 	/**
 	 * Copy the values from this vector to another one.
-	 * @param out - The vector to store the result in.
 	 * @returns The copy.
 	 */
-	public clone<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return copy(this, out);
+	public clone(): Vector3 {
+		return copy(this, new Vector3());
 	}
 
 	/**
@@ -885,151 +852,106 @@ export default class Vector3
 	/**
 	 * Multiply this vector by another.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The product of the vectors.
 	 */
-	public multiply<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return multiply(this, vector, out);
+	public multiply(vector: Vector3Like): Vector3 {
+		return multiply(this, vector, new Vector3());
 	}
 
 	/**
 	 * 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.
 	 */
-	public divide<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return divide(this, vector, out);
+	public divide(vector: Vector3Like): Vector3 {
+		return divide(this, vector, new Vector3());
 	}
 
 	/**
 	 * Subtract another vector from this one.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The difference between the vectors.
 	 */
-	public subtract<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return subtract(this, vector, out);
+	public subtract(vector: Vector3Like): Vector3 {
+		return subtract(this, vector, new Vector3());
 	}
 
 	/**
 	 * Absolutize the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The absolutized vector.
 	 */
-	public abs<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return abs(this, out);
+	public abs(): Vector3 {
+		return abs(this, new Vector3());
 	}
 
 	/**
 	 * Round up the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The rounded vector.
 	 */
-	public ceil<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return ceil(this, out);
+	public ceil(): Vector3 {
+		return ceil(this, new Vector3());
 	}
 
 	/**
 	 * Round down the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The rounded vector.
 	 */
-	public floor<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return floor(this, out);
+	public floor(): Vector3 {
+		return floor(this, new Vector3());
 	}
 
 	/**
 	 * Round the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The rounded vector.
 	 */
-	public round<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return round(this, out);
+	public round(): Vector3 {
+		return round(this, 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.
 	 */
-	public min<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return min(this, vector, out);
+	public min(vector: Vector3Like): Vector3 {
+		return min(this, vector, new Vector3());
 	}
 
 	/**
 	 * Return the maximum of this and another vector.
 	 * @param vector - The other vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The maximum.
 	 */
-	public max<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return max(this, vector, out);
+	public max(vector: Vector3Like): Vector3 {
+		return max(this, vector, new Vector3());
 	}
 
 	/**
 	 * 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).
 	 */
-	public pow<T extends Vector3Like = Vector3>(
-		scalar: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return pow(this, scalar, out);
+	public pow(scalar: number): Vector3 {
+		return pow(this, scalar, new Vector3());
 	}
 
 	/**
 	 * Scale this vector by a scalar.
 	 * @param scalar - The scalar.
-	 * @param out - The vector to store the result in.
 	 * @returns The scaled vector.
 	 */
-	public scale<T extends Vector3Like = Vector3>(
-		scalar: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return scale(this, scalar, out);
+	public scale(scalar: number): Vector3 {
+		return scale(this, scalar, new Vector3());
 	}
 
 	/**
 	 * Add another vector to this one after scaling the other by a scalar.
 	 * @param vector - The other vector.
 	 * @param scalar - The scalar.
-	 * @param out - The vector to store the result in.
 	 * @returns The sum.
 	 */
-	public scaleAndAdd<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		scalar: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return scaleAndAdd(this, vector, scalar, out);
+	public scaleAndAdd(vector: Vector3Like, scalar: number): Vector3 {
+		return scaleAndAdd(this, vector, scalar, new Vector3());
 	}
 
 	/**
@@ -1052,48 +974,47 @@ export default class Vector3
 		return squaredDistance(this, vector);
 	}
 
-	/** Get the magnitude (length) of this vector. */
+	/** The magnitude (length) of this vector. */
 	public get magnitude(): number {
 		return getMagnitude(this);
 	}
 
-	/** Get the squared magnitude (length) of this vector. */
+	public set magnitude(value: number) {
+		scale(normalize(this, this), value, this);
+	}
+
+	/** The squared magnitude (length) of this vector. */
 	public get squaredMagnitude(): number {
 		return getSquaredMagnitude(this);
 	}
 
+	public set squaredMagnitude(value: number) {
+		this.magnitude = Math.sqrt(value);
+	}
+
 	/**
 	 * Negate this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The negated vector.
 	 */
-	public negate<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return negate(this, out);
+	public negate(): Vector3 {
+		return negate(this, new Vector3());
 	}
 
 	/**
 	 * Calculate the multiplicative inverse of the components of this vector.
-	 * @param out - The vector to store the result in.
 	 * @returns The inverted vector.
 	 */
-	public invert<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return invert(this, out);
+	public invert(): Vector3 {
+		return invert(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}
 	 */
-	public normalize<T extends Vector3Like = Vector3>(
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return normalize(this, out);
+	public normalize(): Vector3 {
+		return normalize(this, new Vector3());
 	}
 
 	/**
@@ -1109,31 +1030,22 @@ export default class Vector3
 	/**
 	 * 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}
 	 */
-	public cross<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return cross(this, vector, out);
+	public cross(vector: Vector3Like): Vector3 {
+		return cross(this, vector, 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}
 	 */
-	public lerp<T extends Vector3Like = Vector3>(
-		vector: Vector3Like,
-		t: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return lerp(this, vector, t, out);
+	public lerp(vector: Vector3Like, t: number): Vector3 {
+		return lerp(this, vector, t, new Vector3());
 	}
 
 	/**
@@ -1148,72 +1060,49 @@ export default class Vector3
 	/**
 	 * 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.
 	 */
-	public transformMatrix3<T extends Vector3Like = Vector3>(
-		matrix: Matrix3Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return transformMatrix3(this, matrix, out);
+	public transformMatrix3(matrix: Matrix3Like): Vector3 {
+		return transformMatrix3(this, matrix, new Vector3());
 	}
 
 	/**
 	 * 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.
 	 */
-	public transformMatrix4<T extends Vector3Like = Vector3>(
-		matrix: Matrix4Like,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return transformMatrix4(this, matrix, out);
+	public transformMatrix4(matrix: Matrix4Like): Vector3 {
+		return transformMatrix4(this, matrix, new Vector3());
 	}
 
 	/**
 	 * 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.
 	 */
-	public rotateX<T extends Vector3Like = Vector3>(
-		origin: Vector3Like,
-		r: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return rotateX(this, origin, r, out);
+	public rotateX(origin: Vector3Like, r: number): Vector3 {
+		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.
 	 */
-	public rotateY<T extends Vector3Like = Vector3>(
-		origin: Vector3Like,
-		r: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return rotateY(this, origin, r, out);
+	public rotateY(origin: Vector3Like, r: number): Vector3 {
+		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.
 	 */
-	public rotateZ<T extends Vector3Like = Vector3>(
-		origin: Vector3Like,
-		r: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return rotateZ(this, origin, r, out);
+	public rotateZ(origin: Vector3Like, r: number): Vector3 {
+		return rotateZ(this, origin, r, new Vector3());
 	}
 
 	/**
@@ -1239,18 +1128,16 @@ export default class Vector3
 	 * @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}
 	 */
-	public hermite<T extends Vector3Like = Vector3>(
+	public hermite(
 		a: Vector3Like,
 		b: Vector3Like,
 		end: Vector3Like,
-		t: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return hermite(this, a, b, end, t, out);
+		t: number
+	): Vector3 {
+		return hermite(this, a, b, end, t, new Vector3());
 	}
 
 	/**
@@ -1259,31 +1146,25 @@ export default class Vector3
 	 * @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}
 	 */
-	public bezier<T extends Vector3Like = Vector3>(
+	public bezier(
 		a: Vector3Like,
 		b: Vector3Like,
 		end: Vector3Like,
-		t: number,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return bezier(this, a, b, end, t, out);
+		t: number
+	): Vector3 {
+		return bezier(this, a, b, end, t, 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}
 	 */
-	public transformQuaternion<T extends Vector3Like = Vector3>(
-		quaternion: QuaternionLike,
-		out: T = new Vector3() as Vector3 & T
-	): T {
-		return transformQuaternion(this, quaternion, out);
+	public transformQuaternion(quaternion: QuaternionLike): Vector3 {
+		return transformQuaternion(this, quaternion, new Vector3());
 	}
 }