@lakuna/umath 2.0.0 → 3.0.0

package/src/linalg/Vector.ts

@@ -1,8 +1,4 @@
-/**
- * An object that could be interpreted as a vector.
- * @public
- */
-export type VectorLike = Record<number, number>;
+import type { Vector4Like } from "./Vector4.js";
 
 /**
  * A quantity with magnitude and direction.
@@ -11,179 +7,185 @@ export type VectorLike = Record<number, number>;
  */
 export default interface Vector extends VectorLike {
 	/**
-	 * Determine whether this vector is roughly equivalent to another.
-	 * @param vector - The other vector.
-	 * @returns Whether the vectors are equivalent.
-	 */
-	equals(vector: VectorLike): boolean;
-
-	/**
-	 * Determine whether this vector is exactly equivalent to another.
+	 * Add two vectors of the same size.
 	 * @param vector - The other vector.
-	 * @returns Whether the vectors are equivalent.
+	 * @returns The sum of the vectors.
 	 */
-	exactEquals(vector: VectorLike): boolean;
+	add: (vector: Vector4Like) => VectorLike;
 
 	/**
-	 * Add two vectors of the same size.
-	 * @param vector - The other vector.
-	 * @returns The sum of the vectors.
+	 * Round up the components of this vector.
+	 * @returns The rounded vector.
 	 */
-	add(vector: VectorLike): VectorLike;
+	ceil: () => VectorLike;
 
 	/**
 	 * Create a copy of this vector.
 	 * @returns A copy of this vector.
 	 */
-	clone(): VectorLike;
+	clone: () => VectorLike;
 
 	/**
 	 * Copy the values of another vector into this one.
 	 * @param vector - The vector to copy.
 	 * @returns This vector.
 	 */
-	copy(vector: VectorLike): this;
+	copy: (vector: Vector4Like) => this;
 
 	/**
-	 * Multiply this vector by another.
+	 * Calculate the Euclidean distance between this vector and another.
 	 * @param vector - The other vector.
-	 * @returns The product of the vectors.
+	 * @returns The distance.
 	 */
-	multiply(vector: VectorLike): VectorLike;
+	distance: (vector: Vector4Like) => number;
 
 	/**
 	 * Divide this vector by another.
 	 * @param vector - The other vector.
 	 * @returns The quotient of the vectors.
 	 */
-	divide(vector: VectorLike): VectorLike;
+	divide: (vector: Vector4Like) => VectorLike;
 
 	/**
-	 * Subtract another vector from this one.
+	 * Calculate the dot product of this and another vector.
 	 * @param vector - The other vector.
-	 * @returns The difference between the vectors.
+	 * @returns The dot product.
+	 * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
 	 */
-	subtract(vector: VectorLike): VectorLike;
+	dot: (vector: Vector4Like) => number;
 
 	/**
-	 * Round up the components of this vector.
-	 * @returns The rounded vector.
+	 * Determine whether this vector is roughly equivalent to another.
+	 * @param vector - The other vector.
+	 * @returns Whether the vectors are equivalent.
+	 */
+	equals: (vector: Vector4Like) => boolean;
+
+	/**
+	 * Determine whether this vector is exactly equivalent to another.
+	 * @param vector - The other vector.
+	 * @returns Whether the vectors are equivalent.
 	 */
-	ceil(): VectorLike;
+	exactEquals: (vector: Vector4Like) => boolean;
 
 	/**
 	 * Round down the components of this vector.
 	 * @returns The rounded vector.
 	 */
-	floor(): VectorLike;
+	floor: () => VectorLike;
 
 	/**
-	 * Round the components of this vector.
-	 * @returns The rounded vector.
+	 * Calculate the multiplicative inverse of the components of this vector.
+	 * @returns The inverted vector.
 	 */
-	round(): VectorLike;
+	invert: () => VectorLike;
 
 	/**
-	 * Return the minimum of this and another vector.
+	 * Perform a linear interpolation between this and another vector.
 	 * @param vector - The other vector.
-	 * @returns The minimum.
+	 * @param t - The interpolation amount (in `[0,1]`).
+	 * @returns The interpolated vector.
 	 */
-	min(vector: VectorLike): VectorLike;
+	lerp: (vector: Vector4Like, t: number) => VectorLike;
+
+	/** Get the magnitude (length) of this vector. */
+	get magnitude(): number;
 
 	/**
 	 * Return the maximum of this and another vector.
 	 * @param vector - The other vector.
 	 * @returns The maximum.
 	 */
-	max(vector: VectorLike): VectorLike;
+	max: (vector: Vector4Like) => VectorLike;
 
 	/**
-	 * Raise each component of this vector to the given power.
-	 * @param exponent - The exponent (power) to raise each component to.
-	 * @returns The power (result of the exponentiation).
+	 * Return the minimum of this and another vector.
+	 * @param vector - The other vector.
+	 * @returns The minimum.
 	 */
-	pow(exponent: number): VectorLike;
+	min: (vector: Vector4Like) => VectorLike;
 
 	/**
-	 * Scale this vector by a scalar.
-	 * @param scalar - The scalar.
-	 * @returns The scaled vector.
+	 * Multiply this vector by another.
+	 * @param vector - The other vector.
+	 * @returns The product of the vectors.
 	 */
-	scale(scalar: number): VectorLike;
+	multiply: (vector: Vector4Like) => VectorLike;
 
 	/**
-	 * Add another vector to this one after scaling the other by a scalar.
-	 * @param vector - The other vector.
-	 * @param scalar - The scalar.
-	 * @returns The sum.
+	 * Negate this vector.
+	 * @returns The negated vector.
 	 */
-	scaleAndAdd(vector: VectorLike, scalar: number): VectorLike;
+	negate: () => VectorLike;
 
 	/**
-	 * Calculate the Euclidean distance between this vector and another.
-	 * @param vector - The other vector.
-	 * @returns The distance.
+	 * Normalize this vector.
+	 * @returns The normalized vector.
+	 * @see {@link https://en.wikipedia.org/wiki/Unit_vector | Unit vector}
 	 */
-	distance(vector: VectorLike): number;
+	normalize: () => VectorLike;
 
 	/**
-	 * Calculate the squared Euclidean distance between this vector and another.
-	 * @param vector - The other vector.
-	 * @returns The squared distance.
+	 * Raise each component of this vector to the given power.
+	 * @param exponent - The exponent (power) to raise each component to.
+	 * @returns The power (result of the exponentiation).
 	 */
-	squaredDistance(vector: VectorLike): number;
-
-	/** Get the magnitude (length) of this vector. */
-	get magnitude(): number;
-
-	/** Get the squared magnitude (length) of this vector. */
-	get squaredMagnitude(): number;
+	pow: (exponent: number) => VectorLike;
 
 	/**
-	 * Negate this vector.
-	 * @returns The negated vector.
+	 * Set this vector to a random value with the given magnitude.
+	 * @param magnitude - The magnitude.
+	 * @returns This vector.
 	 */
-	negate(): VectorLike;
+	random: (magnitude: number) => this;
 
 	/**
-	 * Calculate the multiplicative inverse of the components of this vector.
-	 * @returns The inverted vector.
+	 * Round the components of this vector.
+	 * @returns The rounded vector.
 	 */
-	invert(): VectorLike;
+	round: () => VectorLike;
 
 	/**
-	 * Normalize this vector.
-	 * @returns The normalized vector.
-	 * @see {@link https://en.wikipedia.org/wiki/Unit_vector | Unit vector}
+	 * Scale this vector by a scalar.
+	 * @param scalar - The scalar.
+	 * @returns The scaled vector.
 	 */
-	normalize(): VectorLike;
+	scale: (scalar: number) => VectorLike;
 
 	/**
-	 * Calculate the dot product of this and another vector.
+	 * Add another vector to this one after scaling the other by a scalar.
 	 * @param vector - The other vector.
-	 * @returns The dot product.
-	 * @see {@link https://en.wikipedia.org/wiki/Dot_product | Dot product}
+	 * @param scalar - The scalar.
+	 * @returns The sum.
 	 */
-	dot(vector: VectorLike): number;
+	scaleAndAdd: (vector: Vector4Like, scalar: number) => VectorLike;
 
 	/**
-	 * Perform a linear interpolation between this and another vector.
+	 * Calculate the squared Euclidean distance between this vector and another.
 	 * @param vector - The other vector.
-	 * @param t - The interpolation amount (in `[0,1]`).
-	 * @returns The interpolated vector.
+	 * @returns The squared distance.
 	 */
-	lerp(vector: VectorLike, t: number): VectorLike;
+	squaredDistance: (vector: Vector4Like) => number;
+
+	/** Get the squared magnitude (length) of this vector. */
+	get squaredMagnitude(): number;
 
 	/**
-	 * Set this vector to a random value with the given magnitude.
-	 * @param magnitude - The magnitude.
-	 * @returns This vector.
+	 * Subtract another vector from this one.
+	 * @param vector - The other vector.
+	 * @returns The difference between the vectors.
 	 */
-	random(magnitude: number): this;
+	subtract: (vector: Vector4Like) => VectorLike;
 
 	/**
 	 * Set this to the zero vector.
 	 * @returns This vector.
 	 */
-	zero(): this;
+	zero: () => this;
 }
+
+/**
+ * An object that could be interpreted as a vector.
+ * @public
+ */
+export type VectorLike = Record<number, number>;