@lakuna/umath 0.0.2 → 0.0.4

package/src/algorithms/degreesToRadians.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts a given number of degrees to an equivalent number of radians.
+ * @param degrees The number of degrees.
+ * @returns An equivalent number of radians.
+ * @see [Degree](https://en.wikipedia.org/wiki/Degree_(angle))
+ * @see [Radian](https://en.wikipedia.org/wiki/Radian)
+ */
+export default function degreesToRadians(degrees: number): number {
+	return degrees * Math.PI / 180;
+}

package/src/algorithms/factorial.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns the factorial of the given number.
+ * @param n The number.
+ * @returns The factorial of the number.
+ * @see [Factorial](https://en.wikipedia.org/wiki/Factorial)
+ */
+export default function factorial(n: number): number {
+	return n == 0 ? 1 : n * factorial(n - 1);
+}

package/src/algorithms/fibonacci.ts

@@ -0,0 +1,14 @@
+/**
+ * A generator function that returns numbers in the Fibonacci sequence.
+ * @returns The next value in the Fibonacci sequence.
+ * @see [Fibonacci sequence](https://en.wikipedia.org/wiki/Fibonacci_sequence)
+ */
+export default function* fibonacci(): Generator<number> {
+	let a = 0;
+	let b = 1;
+
+	while (true) {
+		yield a;
+		[a, b] = [b, a + b];
+	}
+}

package/src/algorithms/greatestCommonDivisor.ts

@@ -0,0 +1,30 @@
+/**
+ * Determines the greatest common divisor of two integers.
+ * @param a The first integer.
+ * @param b The second integer.
+ * @returns The greatest common divisor of the integers.
+ * @see [Greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor)
+ */
+export default function greatestCommonDivisor(a: bigint, b: bigint): bigint;
+
+/**
+ * Determines the greatest common divisor of two integers.
+ * @param a The first integer.
+ * @param b The second integer.
+ * @returns The greatest common divisor of the integers.
+ * @see [Greatest common divisor](https://en.wikipedia.org/wiki/Greatest_common_divisor)
+ */
+export default function greatestCommonDivisor(a: number, b: number): number;
+
+export default function greatestCommonDivisor(a: bigint | number, b: bigint | number): bigint | number {
+	// Ensure that all of the integers are positive.
+	if (a < 0) { a = -a; }
+	if (b < 0) { b = -b; }
+
+	// Apply the Euclidean algorithm.
+	while (b) {
+		[a, b] = [b, (a as number) % (b as number)];
+	}
+
+	return a;
+}

package/src/algorithms/isPrime.ts

@@ -0,0 +1,20 @@
+/**
+ * Returns whether the given number is prime.
+ * @param n The given number.
+ * @returns Whether the given number is prime.
+ * @see [Prime number](https://en.wikipedia.org/wiki/Prime_number)
+ */
+export default function isPrime(n: number): boolean {
+	// Negatives, zero, and one can't be prime.
+	if (n < 2) {
+		return false;
+	}
+
+	for (let i = 2; i * i <= n; i++) {
+		if (n % i == 0) {
+			return false;
+		}
+	}
+
+	return true;
+}

package/src/algorithms/permutations.ts

@@ -0,0 +1,12 @@
+import { factorial } from "@lakuna/umath";
+
+/**
+ * Calculates the number of permutations.
+ * @param n The total number of units.
+ * @param r The number of units taken at a time.
+ * @returns The number of permutations.
+ * @see [Permutation](https://en.wikipedia.org/wiki/Permutation)
+ */
+export default function permutations(n: number, r: number): number {
+	return factorial(n) / factorial(n - r);
+}

package/src/algorithms/primeFactorization.ts

@@ -0,0 +1,21 @@
+/**
+ * Factors the given number into a list of prime numbers.
+ * @param n The number to factor.
+ * @returns A list of prime number factors of the given number.
+ * @see [Integer factorization](https://en.wikipedia.org/wiki/Integer_factorization)
+ */
+export default function primeFactorization(n: number): Array<number> {
+	const out: Array<number> = [];
+
+	let divisor = 2;
+	while (n >= 2) {
+		if (n % divisor == 0) {
+			out.push(divisor);
+			n /= divisor;
+		} else {
+			divisor++;
+		}
+	}
+
+	return out;
+}

package/src/algorithms/radiansToDegrees.ts

@@ -0,0 +1,10 @@
+/**
+ * Converts a given number of radians to an equivalent number of degrees.
+ * @param radians The number of radians.
+ * @returns An equivalent number of degrees.
+ * @see [Degree](https://en.wikipedia.org/wiki/Degree_(angle))
+ * @see [Radian](https://en.wikipedia.org/wiki/Radian)
+ */
+export default function radiansToDegrees(radians: number): number {
+	return radians * 180 / Math.PI;
+}

package/src/algorithms/summation.ts

@@ -0,0 +1,23 @@
+/**
+ * Recursively sums up the results of the given function.
+ * @param i The index of summation.
+ * @param max The upper bound of the index of summation.
+ * @param term The function used to generate each term.
+ * @returns The sum.
+ * @see [Summation](https://en.wikipedia.org/wiki/Summation)
+ */
+function summationInternal(i: number, max: number, term: (i: number) => number): number {
+	return term(i) + (i < max ? summationInternal(i + 1, max, term) : 0);
+}
+
+/**
+ * Performs a summation.
+ * @param min The lower bound (inclusive) of the index of summation.
+ * @param max The upper bound (inclusive) of the index of summation.
+ * @param term The function used to generate each term.
+ * @returns The sum.
+ * @see [Summation](https://en.wikipedia.org/wiki/Summation)
+ */
+export default function summation(min: number, max: number, term: (i: number) => number): number {
+	return summationInternal(min, max, term);
+}

package/src/index.ts

@@ -1 +1,28 @@
-export const foo = "bar";
+export { default as combinations } from "./algorithms/combinations.js";
+export { default as degreesToRadians } from "./algorithms/degreesToRadians.js";
+export { default as factorial } from "./algorithms/factorial.js";
+export { default as fibonacci } from "./algorithms/fibonacci.js";
+export { default as greatestCommonDivisor } from "./algorithms/greatestCommonDivisor.js";
+export { default as isPrime } from "./algorithms/isPrime.js";
+export { default as permutations } from "./algorithms/permutations.js";
+export { default as primeFactorization } from "./algorithms/primeFactorization.js";
+export { default as radiansToDegrees } from "./algorithms/radiansToDegrees.js";
+export { default as summation } from "./algorithms/summation.js";
+export { type DualQuaternionLike, default as DualQuaternion } from "@lakuna/umath/DualQuaternion";
+export type { MatrixLike, default as Matrix } from "./linear/Matrix.js";
+export { type Matrix2Like, default as Matrix2 } from "@lakuna/umath/Matrix2";
+export { type Matrix3Like, default as Matrix3 } from "@lakuna/umath/Matrix3";
+export { type Matrix4Like, default as Matrix4 } from "@lakuna/umath/Matrix4";
+export { type QuaternionLike, default as Quaternion } from "@lakuna/umath/Quaternion";
+export type { default as SquareMatrix } from "./linear/SquareMatrix.js";
+export type { VectorLike, default as Vector } from "./linear/Vector.js";
+export { type Vector2Like, default as Vector2 } from "@lakuna/umath/Vector2";
+export { type Vector3Like, default as Vector3 } from "@lakuna/umath/Vector3";
+export { type Vector4Like, default as Vector4 } from "@lakuna/umath/Vector4";
+export type { default as AxisAngle } from "./types/AxisAngle.js";
+export type { default as FieldOfView } from "./types/FieldOfView.js";
+export type { IntegerRepresentation } from "./types/IntegerRepresentation.js";
+export { default as BigNumber } from "./utility/BigNumber.js";
+export { default as epsilon } from "./utility/epsilon.js";
+export { default as MagnitudeError } from "./utility/MagnitudeError.js";
+export { default as SingularMatrixError } from "./utility/SingularMatrixError.js";