@lakuna/umath 0.0.2 → 0.0.4

package/src/types/AxisAngle.ts

@@ -0,0 +1,10 @@
+import type { Vector3Like } from "@lakuna/umath/Vector3";
+
+/** An axis and an angle to rotate around it. */
+export default interface AxisAngle {
+    /** The axis to rotate around. */
+    axis: Vector3Like;
+
+    /** The angle to rotate around the axis by in radians. */
+    angle: number;
+}

package/src/types/FieldOfView.ts

@@ -0,0 +1,14 @@
+/** A field of view. */
+export default interface FieldOfView {
+	/** The angle to the top of the field of view in degrees. */
+	upDegrees: number;
+
+	/** The angle to the bottom of the field of view in degrees. */
+	downDegrees: number;
+
+	/** The angle to the left edge of the field of view in degrees. */
+	leftDegrees: number;
+
+	/** The angle to the right edge of the field of view in degrees. */
+	rightDegrees: number;
+}

package/src/types/IntegerRepresentation.ts

@@ -0,0 +1,2 @@
+/** A value that represents an integer. */
+export type IntegerRepresentation = string | number | bigint | boolean;

package/src/utility/BigNumber.ts

@@ -0,0 +1,130 @@
+import { greatestCommonDivisor, type IntegerRepresentation } from "@lakuna/umath";
+
+/** A number with no maximum precise size. */
+export default class BigNumber {
+	/**
+	 * Creates a number.
+	 * @param source The number.
+	 */
+	public constructor(source?: IntegerRepresentation);
+
+	/**
+	 * Creates a number from a fraction.
+	 * @param dividend The dividend of the fraction.
+	 * @param divisor The divisor of the fraction.
+	 */
+	public constructor(dividend?: IntegerRepresentation, divisor?: IntegerRepresentation);
+
+	public constructor(dividend: IntegerRepresentation = 0, divisor: IntegerRepresentation = 1) {
+		this.dividend = BigInt(dividend);
+		this.divisor = BigInt(divisor);
+		if (!this.divisor) { throw new Error("Cannot divide by zero."); }
+		this.simplify();
+	}
+
+	/** The dividend of this fraction. */
+	public dividend: bigint;
+
+	/** The divisor of this fraction. */
+	public divisor: bigint;
+
+	/** Simplifies this fraction. */
+	private simplify(): void {
+		// Switches signs such that only the dividend can be negative.
+		if (this.divisor < 0) {
+			this.dividend = -this.dividend;
+			this.divisor = -this.divisor;
+		}
+
+		// Divide both by their greatest common divisor.
+		const gcd: bigint = greatestCommonDivisor(this.dividend, this.divisor);
+		if (gcd > 1) {
+			this.dividend /= gcd;
+			this.divisor /= gcd;
+		}
+	}
+
+	/**
+	 * Adds a number to this number.
+	 * @param n The other number.
+	 * @returns This number.
+	 */
+	public add(n: IntegerRepresentation | BigNumber): this {
+		if (n instanceof BigNumber) {
+			this.dividend = this.dividend * n.divisor + n.dividend * this.divisor;
+			this.divisor *= n.divisor;
+		} else {
+			this.dividend += BigInt(n) * this.divisor;
+		}
+
+		this.simplify();
+		return this;
+	}
+
+	/**
+	 * Subtracts a number from this number.
+	 * @param n The other number.
+	 * @returns This number.
+	 */
+	public subtract(n: IntegerRepresentation | BigNumber): this {
+		if (n instanceof BigNumber) {
+			this.dividend = this.dividend * n.divisor - n.dividend * this.divisor;
+			this.divisor *= n.divisor;
+		} else {
+			this.dividend -= BigInt(n) * this.divisor;
+		}
+
+		this.simplify();
+		return this;
+	}
+
+	/**
+	 * Multiplies this number by a number.
+	 * @param n The other number.
+	 * @returns This number.
+	 */
+	public multiply(n: IntegerRepresentation | BigNumber): this {
+		if (n instanceof BigNumber) {
+			this.dividend *= n.dividend;
+			this.divisor *= n.divisor;
+		} else {
+			this.dividend *= BigInt(n);
+		}
+
+		this.simplify();
+		return this;
+	}
+
+	/**
+	 * Divides this number by a number.
+	 * @param n The other number.
+	 * @returns This number.
+	 */
+	public divide(n: IntegerRepresentation | BigNumber): this {
+		if (n instanceof BigNumber) {
+			this.dividend *= n.divisor;
+			this.divisor *= n.dividend;
+		} else {
+			this.divisor *= BigInt(n);
+		}
+
+		this.simplify();
+		return this;
+	}
+
+	/**
+	 * Converts this number to a regular `number`. Might result in loss of precision.
+	 * @returns This number as a `number`.
+	 */
+	public toNumber(): number {
+		return Number(this.dividend / this.divisor) + (Number(this.dividend % this.divisor) / Number(this.divisor));
+	}
+
+	/**
+	 * Converts this number to a string.
+	 * @returns A string representation of this number.
+	 */
+	public toString(): string {
+		return `${this.dividend}/${this.divisor}`;
+	}
+}

package/src/utility/MagnitudeError.ts

@@ -0,0 +1,10 @@
+/** An error resulting from using a vector that is too small. */
+export default class MagnitudeError extends Error {
+    /**
+     * Creates an error resulting from using a vector that is too small.
+     * @param message The message of the error.
+     */
+    public constructor(message = "The vector is too small.") {
+        super(message);
+    }
+}

package/src/utility/SingularMatrixError.ts

@@ -0,0 +1,13 @@
+/**
+ * An error resulting from trying to invert a singular matrix.
+ * @see [Invertible matrix](https://en.wikipedia.org/wiki/Invertible_matrix)
+ */
+export default class SingularMatrixError extends Error {
+    /**
+     * Creates an error resulting from trying to invert a singular matrix.
+     * @param message The message of the error.
+     */
+    public constructor(message = "The matrix cannot be inverted.") {
+        super(message);
+    }
+}

package/src/utility/epsilon.ts

@@ -0,0 +1,2 @@
+/** The largest difference between two numbers for them to be considered "roughly" equivalent. */
+export default 0.000001;