@inglorious/engine 0.1.0 → 0.2.0

package/src/utils/math/numbers.test.js

@@ -1,137 +1,137 @@
-import { expect, test } from "vitest"
-
-import { abs, clamp, isClose, mod, sign, snap, sqrt } from "./numbers.js"
-
-test("it should return the same number if already positive", () => {
-  const num = 42
-  const expectedResult = 42
-
-  expect(abs(num)).toBe(expectedResult)
-})
-
-test("it should return the absolute value of a number", () => {
-  const num = -42
-  const expectedResult = 42
-
-  expect(abs(num)).toBe(expectedResult)
-})
-
-test("it should not clamp a number in the range", () => {
-  const num = 42
-  const min = 0
-  const max = 100
-  const expectedResult = 42
-
-  expect(clamp(num, min, max)).toBe(expectedResult)
-})
-
-test("it should clamp a number too small", () => {
-  const num = -42
-  const min = 0
-  const max = 100
-  const expectedResult = 0
-
-  expect(clamp(num, min, max)).toBe(expectedResult)
-})
-
-test("it should clamp a number too big", () => {
-  const num = 142
-  const min = 0
-  const max = 100
-  const expectedResult = 100
-
-  expect(clamp(num, min, max)).toBe(expectedResult)
-})
-
-test("it should check if two numbers are close given some tolerance", () => {
-  const num1 = 42
-  const num2 = 42.1
-  const tolerance = 0.2
-  const expectedResult = true
-
-  expect(isClose(num1, num2, tolerance)).toBe(expectedResult)
-})
-
-test("it should return zero if dividend equals divisor", () => {
-  const num = 2
-  const divisor = 2
-  const expectedResult = 0
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should return one if number is odd", () => {
-  const num = 3
-  const divisor = 2
-  const expectedResult = 1
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should return one if negative number turns to positive one", () => {
-  const num = -3
-  const divisor = 2
-  const expectedResult = 1
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should convert a float number greater than 1 to a range between -1 and 1", () => {
-  const num = 5 / 4
-  const divisor = 1
-  const expectedResult = 1 / 4
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should convert a float number greater than 2 to a range between -1 and 1", () => {
-  const num = 13 / 4
-  const divisor = 1
-  const expectedResult = 1 / 4
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should convert a negative float number to a range between -1 and 1", () => {
-  const num = -5 / 4
-  const divisor = 1
-  const expectedResult = 3 / 4
-
-  expect(mod(num, divisor)).toBe(expectedResult)
-})
-
-test("it should return one if number is positive", () => {
-  const num = 42
-  const expectedResult = 1
-
-  expect(sign(num)).toBe(expectedResult)
-})
-
-test("it should return minus one if number is negative", () => {
-  const num = -42
-  const expectedResult = -1
-
-  expect(sign(num)).toBe(expectedResult)
-})
-
-test("it should return the number itself if the sign is zero", () => {
-  const num = 0
-  const expectedResult = 0
-
-  expect(sign(num)).toBe(expectedResult)
-})
-
-test("it should snap the number to the given precision", () => {
-  const num = 42
-  const precision = 10
-  const expectedResult = 40
-
-  expect(snap(num, precision)).toBe(expectedResult)
-})
-
-test("it should compute the square root of the number", () => {
-  const num = 9
-  const expectedResult = 3
-
-  expect(sqrt(num)).toBe(expectedResult)
-})
+import { expect, test } from "vitest"
+
+import { abs, clamp, isClose, mod, sign, snap, sqrt } from "./numbers.js"
+
+test("it should return the same number if already positive", () => {
+  const num = 42
+  const expectedResult = 42
+
+  expect(abs(num)).toBe(expectedResult)
+})
+
+test("it should return the absolute value of a number", () => {
+  const num = -42
+  const expectedResult = 42
+
+  expect(abs(num)).toBe(expectedResult)
+})
+
+test("it should not clamp a number in the range", () => {
+  const num = 42
+  const min = 0
+  const max = 100
+  const expectedResult = 42
+
+  expect(clamp(num, min, max)).toBe(expectedResult)
+})
+
+test("it should clamp a number too small", () => {
+  const num = -42
+  const min = 0
+  const max = 100
+  const expectedResult = 0
+
+  expect(clamp(num, min, max)).toBe(expectedResult)
+})
+
+test("it should clamp a number too big", () => {
+  const num = 142
+  const min = 0
+  const max = 100
+  const expectedResult = 100
+
+  expect(clamp(num, min, max)).toBe(expectedResult)
+})
+
+test("it should check if two numbers are close given some tolerance", () => {
+  const num1 = 42
+  const num2 = 42.1
+  const tolerance = 0.2
+  const expectedResult = true
+
+  expect(isClose(num1, num2, tolerance)).toBe(expectedResult)
+})
+
+test("it should return zero if dividend equals divisor", () => {
+  const num = 2
+  const divisor = 2
+  const expectedResult = 0
+
+  expect(mod(num, divisor)).toBe(expectedResult)
+})
+
+test("it should return one if number is odd", () => {
+  const num = 3
+  const divisor = 2
+  const expectedResult = 1
+
+  expect(mod(num, divisor)).toBe(expectedResult)
+})
+
+test("it should return one if negative number turns to positive one", () => {
+  const num = -3
+  const divisor = 2
+  const expectedResult = 1
+
+  expect(mod(num, divisor)).toBe(expectedResult)
+})
+
+test("it should convert a float number greater than 1 to a range between -1 and 1", () => {
+  const num = 5 / 4
+  const divisor = 1
+  const expectedResult = 1 / 4
+
+  expect(mod(num, divisor)).toBe(expectedResult)
+})
+
+test("it should convert a float number greater than 2 to a range between -1 and 1", () => {
+  const num = 13 / 4
+  const divisor = 1
+  const expectedResult = 1 / 4
+
+  expect(mod(num, divisor)).toBe(expectedResult)
+})
+
+test("it should convert a negative float number to a range between -1 and 1", () => {
+  const num = -5 / 4
+  const divisor = 1
+  const expectedResult = 3 / 4
+
+  expect(mod(num, divisor)).toBe(expectedResult)
+})
+
+test("it should return one if number is positive", () => {
+  const num = 42
+  const expectedResult = 1
+
+  expect(sign(num)).toBe(expectedResult)
+})
+
+test("it should return minus one if number is negative", () => {
+  const num = -42
+  const expectedResult = -1
+
+  expect(sign(num)).toBe(expectedResult)
+})
+
+test("it should return the number itself if the sign is zero", () => {
+  const num = 0
+  const expectedResult = 0
+
+  expect(sign(num)).toBe(expectedResult)
+})
+
+test("it should snap the number to the given precision", () => {
+  const num = 42
+  const precision = 10
+  const expectedResult = 40
+
+  expect(snap(num, precision)).toBe(expectedResult)
+})
+
+test("it should compute the square root of the number", () => {
+  const num = 9
+  const expectedResult = 3
+
+  expect(sqrt(num)).toBe(expectedResult)
+})

package/src/utils/math/rng.js

@@ -1,44 +1,44 @@
-/* eslint-disable no-magic-numbers */
-
-/**
- * Generates a random number.
- * - If no arguments are provided, returns a random float between 0 (inclusive) and 1 (exclusive).
- * - If one argument is provided, returns a random integer between 0 and the given number (inclusive).
- * - If two or more arguments are provided, returns a random integer within the specified range and step.
- *
- * @param {number} [to] - The upper bound (inclusive) if one argument is provided.
- * @param {number} [from] - The lower bound (inclusive) if two arguments are provided.
- * @param {number} [step=1] - The step size if two or more arguments are provided.
- * @returns {number} A random number based on the provided arguments.
- */
-export function random(...args) {
-  let step, from, to
-
-  if (!args.length) {
-    return Math.random()
-  }
-
-  if (args.length === 1) {
-    step = 1
-    from = 0
-    to = args[0] + 1
-  }
-
-  if (args.length > 1) {
-    step = args[2] ?? 1
-    from = args[0] / step
-    to = (args[1] + 1) / step
-  }
-
-  return Math.floor(Math.random() * (to - from) + from) * step
-}
-
-/**
- * Generates a random binomial value.
- * The result is the difference between two random numbers.
- *
- * @returns {number} A random binomial value.
- */
-export function randomBinomial() {
-  return random() - random()
-}
+/* eslint-disable no-magic-numbers */
+
+/**
+ * Generates a random number.
+ * - If no arguments are provided, returns a random float between 0 (inclusive) and 1 (exclusive).
+ * - If one argument is provided, returns a random integer between 0 and the given number (inclusive).
+ * - If two or more arguments are provided, returns a random integer within the specified range and step.
+ *
+ * @param {number} [to] - The upper bound (inclusive) if one argument is provided.
+ * @param {number} [from] - The lower bound (inclusive) if two arguments are provided.
+ * @param {number} [step=1] - The step size if two or more arguments are provided.
+ * @returns {number} A random number based on the provided arguments.
+ */
+export function random(...args) {
+  let step, from, to
+
+  if (!args.length) {
+    return Math.random()
+  }
+
+  if (args.length === 1) {
+    step = 1
+    from = 0
+    to = args[0] + 1
+  }
+
+  if (args.length > 1) {
+    step = args[2] ?? 1
+    from = args[0] / step
+    to = (args[1] + 1) / step
+  }
+
+  return Math.floor(Math.random() * (to - from) + from) * step
+}
+
+/**
+ * Generates a random binomial value.
+ * The result is the difference between two random numbers.
+ *
+ * @returns {number} A random binomial value.
+ */
+export function randomBinomial() {
+  return random() - random()
+}

package/src/utils/math/rng.test.js

@@ -1,39 +1,39 @@
-import { expect, test } from "vitest"
-
-import { random, randomBinomial } from "./rng.js"
-
-test("it should create a random number in the range [0, 1)", () => {
-  const randomNumber = random()
-
-  expect(randomNumber).toBeGreaterThanOrEqual(0)
-  expect(randomNumber).toBeLessThan(1)
-})
-
-test("it should create a random integer in the range [0, 6]", () => {
-  const randomNumber = random(6)
-
-  expect(randomNumber).toBeGreaterThanOrEqual(0)
-  expect(randomNumber).toBeLessThanOrEqual(6)
-})
-
-test("it should create a random integer in the range [1, 6]", () => {
-  const randomNumber = random(1, 6)
-
-  expect(randomNumber).toBeGreaterThanOrEqual(1)
-  expect(randomNumber).toBeLessThanOrEqual(6)
-})
-
-test("it should create a random even number in the range [2, 6]", () => {
-  const randomNumber = random(2, 6, 2)
-
-  expect(randomNumber).toBeGreaterThanOrEqual(1)
-  expect(randomNumber).toBeLessThanOrEqual(6)
-  expect(randomNumber % 2).toBe(0)
-})
-
-test("it should create a random number in the range (-1, 1)", () => {
-  const randomNumber = randomBinomial()
-
-  expect(randomNumber).toBeGreaterThan(-1)
-  expect(randomNumber).toBeLessThan(1)
-})
+import { expect, test } from "vitest"
+
+import { random, randomBinomial } from "./rng.js"
+
+test("it should create a random number in the range [0, 1)", () => {
+  const randomNumber = random()
+
+  expect(randomNumber).toBeGreaterThanOrEqual(0)
+  expect(randomNumber).toBeLessThan(1)
+})
+
+test("it should create a random integer in the range [0, 6]", () => {
+  const randomNumber = random(6)
+
+  expect(randomNumber).toBeGreaterThanOrEqual(0)
+  expect(randomNumber).toBeLessThanOrEqual(6)
+})
+
+test("it should create a random integer in the range [1, 6]", () => {
+  const randomNumber = random(1, 6)
+
+  expect(randomNumber).toBeGreaterThanOrEqual(1)
+  expect(randomNumber).toBeLessThanOrEqual(6)
+})
+
+test("it should create a random even number in the range [2, 6]", () => {
+  const randomNumber = random(2, 6, 2)
+
+  expect(randomNumber).toBeGreaterThanOrEqual(1)
+  expect(randomNumber).toBeLessThanOrEqual(6)
+  expect(randomNumber % 2).toBe(0)
+})
+
+test("it should create a random number in the range (-1, 1)", () => {
+  const randomNumber = randomBinomial()
+
+  expect(randomNumber).toBeGreaterThan(-1)
+  expect(randomNumber).toBeLessThan(1)
+})

package/src/utils/math/statistics.js

@@ -1,43 +1,43 @@
-const HALF = 2
-const AROUND_INDEX = 1
-const NO_OCCURRENCES = 0
-
-export const average = mean
-
-export function mean(...numbers) {
-  return numbers.reduce((acc, num) => acc + num) / numbers.length
-}
-
-export function median(...numbers) {
-  const sortedNumbers = numbers.toSorted()
-  const middleIndex = numbers.length / HALF
-
-  if (Number.isInteger(middleIndex)) {
-    return mean(
-      ...sortedNumbers.slice(
-        middleIndex - AROUND_INDEX,
-        middleIndex + AROUND_INDEX,
-      ),
-    )
-  }
-
-  return sortedNumbers[Math.floor(middleIndex)]
-}
-
-export function mode(...values) {
-  const occurrences = values.reduce((acc, value) => {
-    acc[value] = acc[value] ?? NO_OCCURRENCES
-    acc[value]++
-    return acc
-  }, {})
-
-  return Object.entries(occurrences).reduce(
-    (acc, [value, occurrences]) => {
-      if (occurrences > acc.occurrences) {
-        acc = { value, occurrences }
-      }
-      return acc
-    },
-    { occurrences: 0 },
-  ).value
-}
+const HALF = 2
+const AROUND_INDEX = 1
+const NO_OCCURRENCES = 0
+
+export const average = mean
+
+export function mean(...numbers) {
+  return numbers.reduce((acc, num) => acc + num) / numbers.length
+}
+
+export function median(...numbers) {
+  const sortedNumbers = numbers.toSorted()
+  const middleIndex = numbers.length / HALF
+
+  if (Number.isInteger(middleIndex)) {
+    return mean(
+      ...sortedNumbers.slice(
+        middleIndex - AROUND_INDEX,
+        middleIndex + AROUND_INDEX,
+      ),
+    )
+  }
+
+  return sortedNumbers[Math.floor(middleIndex)]
+}
+
+export function mode(...values) {
+  const occurrences = values.reduce((acc, value) => {
+    acc[value] = acc[value] ?? NO_OCCURRENCES
+    acc[value]++
+    return acc
+  }, {})
+
+  return Object.entries(occurrences).reduce(
+    (acc, [value, occurrences]) => {
+      if (occurrences > acc.occurrences) {
+        acc = { value, occurrences }
+      }
+      return acc
+    },
+    { occurrences: 0 },
+  ).value
+}

package/src/utils/math/statistics.test.js

@@ -1,47 +1,47 @@
-import { expect, test } from "vitest"
-
-import { mean, median, mode } from "./statistics.js"
-
-test("it should return the average of the given numbers", () => {
-  const numbers = [1, 3, 2]
-  const expectedResult = 2
-
-  expect(mean(...numbers)).toBeCloseTo(expectedResult)
-})
-
-test("it should return the median value from an odd list of numbers", () => {
-  const numbers = [1, 3, 2]
-  const expectedResult = 2
-
-  expect(median(...numbers)).toBe(expectedResult)
-})
-
-test("it should return the median value from an even list of numbers", () => {
-  const numbers = [1, 3, 2, 4]
-  const expectedResult = 2.5
-
-  expect(median(...numbers)).toBe(expectedResult)
-})
-
-test("it should find the mode of a list of values", () => {
-  const values = [
-    "rarely",
-    "seldom",
-    "seldom",
-    "sometimes",
-    "sometimes",
-    "sometimes",
-    "often",
-    "often",
-    "often",
-    "often",
-    "always",
-    "always",
-    "always",
-    "always",
-    "always",
-  ]
-  const expectedResult = "always"
-
-  expect(mode(...values)).toBe(expectedResult)
-})
+import { expect, test } from "vitest"
+
+import { mean, median, mode } from "./statistics.js"
+
+test("it should return the average of the given numbers", () => {
+  const numbers = [1, 3, 2]
+  const expectedResult = 2
+
+  expect(mean(...numbers)).toBeCloseTo(expectedResult)
+})
+
+test("it should return the median value from an odd list of numbers", () => {
+  const numbers = [1, 3, 2]
+  const expectedResult = 2
+
+  expect(median(...numbers)).toBe(expectedResult)
+})
+
+test("it should return the median value from an even list of numbers", () => {
+  const numbers = [1, 3, 2, 4]
+  const expectedResult = 2.5
+
+  expect(median(...numbers)).toBe(expectedResult)
+})
+
+test("it should find the mode of a list of values", () => {
+  const values = [
+    "rarely",
+    "seldom",
+    "seldom",
+    "sometimes",
+    "sometimes",
+    "sometimes",
+    "often",
+    "often",
+    "often",
+    "often",
+    "always",
+    "always",
+    "always",
+    "always",
+    "always",
+  ]
+  const expectedResult = "always"
+
+  expect(mode(...values)).toBe(expectedResult)
+})