@inglorious/utils 3.6.3 → 3.7.1

package/src/math/numbers.test.js

@@ -1,198 +0,0 @@
-import { expect, test } from "vitest"
-
-import {
-  abs,
-  clamp,
-  isBetween,
-  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 return true if a number is between min and max", () => {
-  const num = 50
-  const min = 0
-  const max = 100
-  const expectedResult = true
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return true if a number is equal to min", () => {
-  const num = 0
-  const min = 0
-  const max = 100
-  const expectedResult = true
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return true if a number is equal to max", () => {
-  const num = 100
-  const min = 0
-  const max = 100
-  const expectedResult = true
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return false if a number is lower than min", () => {
-  const num = -1
-  const min = 0
-  const max = 100
-  const expectedResult = false
-
-  expect(isBetween(num, min, max)).toBe(expectedResult)
-})
-
-test("it should return false if a number is greater than max", () => {
-  const num = 101
-  const min = 0
-  const max = 100
-  const expectedResult = false
-
-  expect(isBetween(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 the dividend if the divisor is zero", () => {
-  const num = 42
-  const divisor = 0
-
-  expect(mod(num, divisor)).toBe(num)
-})
-
-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/math/point.test.js

@@ -1,94 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import {
-  intersectsCircle,
-  intersectsPoint,
-  intersectsRectangle,
-} from "./point.js"
-
-test("it should prove that two equal points intersect", () => {
-  const point1 = v(1.5, 1.5, 0)
-  const point2 = v(1.5, 1.5, 0)
-
-  expect(intersectsPoint(point1, point2)).toBe(true)
-})
-
-test("it should prove that two different points do not intersect", () => {
-  const point1 = v(1.5, 1.5, 0)
-  const point2 = v(2, 1, 0)
-
-  expect(intersectsPoint(point1, point2)).toBe(false)
-})
-
-test("it should prove that a point inside of a circle intersects with it", () => {
-  const point = v(1.5, 1.5, 0)
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(true)
-})
-
-test("it should prove that a point on the border of a circle intersects with it", () => {
-  const point = v(2, 1, 0)
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(true)
-})
-
-test("it should prove that a point outside of a circle does not intersect with it", () => {
-  const point = v(2, 2, 0)
-  const circle = {
-    position: v(1, 1, 0),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(point, circle)).toBe(false)
-})
-
-test("it should prove that a point inside of a rectangle intersects with it", () => {
-  const point = v(1.5, 1.5, 0)
-  const rectangle = {
-    position: v(1, 1, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(true)
-})
-
-test("it should prove that a point on the border of a rectangle intersects with it", () => {
-  const point = v(2, 1, 0)
-  const rectangle = {
-    position: v(1, 1, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(true)
-})
-
-test("it should prove that a point outside of a rectangle does not intersect with it", () => {
-  const point = v(2.5, 2.5, 0)
-  const rectangle = {
-    position: v(1, 1, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(false)
-})
-
-test("it should work even if the point is an object with a position", () => {
-  const point = {
-    position: v(1.5, 1.5, 0),
-  }
-  const rectangle = {
-    position: v(1, 1, 0),
-    size: v(2, 2, 0),
-  }
-
-  expect(intersectsRectangle(point, rectangle)).toBe(true)
-})

package/src/math/quaternion.test.js

@@ -1,25 +0,0 @@
-import { expect, test } from "vitest"
-
-import { quaternion } from "./quaternion.js"
-import { cos, pi, sin } from "./trigonometry.js"
-
-test("it should return the quaternion for no rotation", () => {
-  const angle = 0
-  const expectedResult = [1, 0, 0, 0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})
-
-test("it should return the quaternion for a rotation of pi/2", () => {
-  const angle = pi() / 2
-  const expectedResult = [cos(pi() / 4), 0, sin(pi() / 4), 0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})
-
-test("it should return the quaternion for a rotation of negative pi/2", () => {
-  const angle = -pi() / 2
-  const expectedResult = [cos(-pi() / 4), -0, sin(-pi() / 4), -0]
-
-  expect(quaternion(angle)).toStrictEqual(expectedResult)
-})

package/src/math/quaternions.test.js

@@ -1,29 +0,0 @@
-import { expect, test } from "vitest"
-
-import { quaternion } from "./quaternion.js"
-import { combine } from "./quaternions.js"
-import { cos, pi, sin } from "./trigonometry.js"
-
-test("it should combine two zero-angle quaternions by giving the same 0-angle quaternion", () => {
-  const q1 = quaternion(0)
-  const q2 = quaternion(0)
-  const expectedResult = [1, 0, 0, 0]
-
-  expect(combine(q1, q2)).toStrictEqual(expectedResult)
-})
-
-test("it should combine a zero-angle quaternion with a nonzero-angle quaternion", () => {
-  const q1 = quaternion(0)
-  const q2 = quaternion(pi() / 2)
-  const expectedResult = [cos(pi() / 4), 0, sin(pi() / 4), 0]
-
-  expect(combine(q1, q2)).toStrictEqual(expectedResult)
-})
-
-test("it should combine two nonzero-angle quaternions", () => {
-  const q1 = quaternion(pi() / 2)
-  const q2 = quaternion(pi() / 2)
-  const expectedResult = [2.220446049250313e-16, 0, 1, 0] // close to [0, 0, 1, 0]
-
-  expect(combine(q1, q2)).toStrictEqual(expectedResult)
-})

package/src/math/rectangle.test.js

@@ -1,43 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import { intersectsRectangle } from "./rectangle.js"
-
-test("it should prove that a rectangle crossing another one intersects with it", () => {
-  const rectangle1 = {
-    position: v(0, 0, 0),
-    size: v(2, 2, 2),
-  }
-  const rectangle2 = {
-    position: v(1, 1, 1),
-    size: v(2, 2, 2),
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(true)
-})
-
-test("it should prove that a rectangle right on top of another intersects with it", () => {
-  const rectangle1 = {
-    position: v(0, 0, 0),
-    size: v(2, 2, 2),
-  }
-  const rectangle2 = {
-    position: v(0, 0, 0),
-    size: v(2, 0, 2),
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(true)
-})
-
-test("it should prove that a rectangle not crossing another one does not intersect with it", () => {
-  const rectangle1 = {
-    position: v(0, 0, 0),
-    size: v(2, 2, 2),
-  }
-  const rectangle2 = {
-    position: v(3, 3, 3),
-    size: v(2, 2, 2),
-  }
-
-  expect(intersectsRectangle(rectangle1, rectangle2)).toBe(false)
-})

package/src/math/rng.test.js

@@ -1,55 +0,0 @@
-import { expect, test } from "vitest"
-
-import { choose, random, randomBinomial } from "./rng.js"
-
-test("it should choose a random value from the given arguments", () => {
-  const values = ["a", "b", "c"]
-  const chosenValue = choose(...values)
-
-  expect(values).toContain(chosenValue)
-})
-
-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 float in the range [1.5, 6.5)", () => {
-  const from = 1.5
-  const to = 6.5
-  const randomNumber = random(from, to)
-
-  expect(randomNumber).toBeGreaterThanOrEqual(from)
-  expect(randomNumber).toBeLessThan(to)
-})
-
-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/math/segment.test.js

@@ -1,184 +0,0 @@
-import { expect, test } from "vitest"
-
-import { v } from "../v.js"
-import { isClose } from "./numbers.js"
-import {
-  closestPoint,
-  coefficients,
-  distanceFromPoint,
-  intersectsCircle,
-} from "./segment.js"
-
-expect.extend({
-  toStrictEqualVector(received, expected) {
-    const { isNot } = this
-    return {
-      pass: received.every((coord, index) => isClose(coord, expected[index])),
-      message: () =>
-        `${received} is ${isNot ? "" : "not"} close to ${expected}`,
-    }
-  },
-})
-
-test("it should retrieve values of *a*, *b*, and *c* from a segment, so it looks like a line in the form *ax + by + c = 0*", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(1, 0, 2),
-  }
-  const expectedResult = v(-2, 1, 0)
-
-  expect(coefficients(segment)).toStrictEqual(expectedResult)
-})
-
-test("it should find the closest point in a segment to a point projectable on it", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(2, 0, 2),
-  }
-  const point = v(2, 0, 0)
-  const expectedResult = v(1, 0, 1)
-
-  expect(closestPoint(segment, point)).toStrictEqualVector(expectedResult)
-})
-
-test("it should find the closest point as the point itself when resting on the segment", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(2, 0, 2),
-  }
-  const point = v(1, 0, 1)
-  const expectedResult = v(1, 0, 1)
-
-  expect(closestPoint(segment, point)).toStrictEqualVector(expectedResult)
-})
-
-test("it return the start of a segment when the point is close to its start", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(3, 0, 4),
-  }
-  const point = v(-2, 0, 0)
-  const expectedResult = v(0, 0, 0)
-
-  expect(closestPoint(segment, point)).toStrictEqualVector(expectedResult)
-})
-
-test("it should return the end of a segment when the point is close to its end", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(3, 0, 4),
-  }
-  const point = v(5, 0, 4)
-  const expectedResult = v(3, 0, 4)
-
-  expect(closestPoint(segment, point)).toStrictEqualVector(expectedResult)
-})
-
-test("it should compute the distance between a segment and a point projectable on it", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(3, 0, 4),
-  }
-  const point = v(5, 0, 0)
-  const expectedResult = 4
-
-  expect(distanceFromPoint(segment, point)).toBe(expectedResult)
-})
-
-test("it should compute the distance between a segment and a point resting on it", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(2, 0, 2),
-  }
-  const point = v(1, 0, 1)
-  const expectedResult = 0
-
-  expect(distanceFromPoint(segment, point)).toBeCloseTo(expectedResult)
-})
-
-test("it should compute the distance between a segment and a point close to the start", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(3, 0, 4),
-  }
-  const point = v(-2, 0, 0)
-  const expectedResult = 2
-
-  expect(distanceFromPoint(segment, point)).toBe(expectedResult)
-})
-
-test("it should compute the distance between a segment and a point close to the end", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(3, 0, 4),
-  }
-  const point = v(5, 0, 4)
-  const expectedResult = 2
-
-  expect(distanceFromPoint(segment, point)).toBeCloseTo(expectedResult)
-})
-
-test("it should prove that a segment that crosses a circle intersects with it", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(2, 0, 2),
-  }
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(true)
-})
-
-test("it should prove that a segment tangent to a circle intersects with it", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(0, 0, 2),
-  }
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(true)
-})
-
-test("it should prove that a segment inside of a circle intersects with it", () => {
-  const segment = {
-    from: v(0.5, 0, 0.5),
-    to: v(1.5, 0, 1.5),
-  }
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(true)
-})
-
-test("it should prove that a segment that does not cross a circle does not intersect with it", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(-2, 0, 2),
-  }
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(false)
-})
-
-test("it should prove that a segment that reaches outside of a circle does not intersect with it", () => {
-  const segment = {
-    from: v(0, 0, 0),
-    to: v(-1, 0, -2),
-  }
-  const circle = {
-    position: v(1, 0, 1),
-    radius: 1,
-  }
-
-  expect(intersectsCircle(segment, circle)).toBe(false)
-})

package/src/math/statistics.test.js

@@ -1,47 +0,0 @@
-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)
-})

package/src/math/triangle.test.js

@@ -1,11 +0,0 @@
-import { expect, test } from "vitest"
-
-import { hypothenuse } from "./triangle.js"
-
-test("it should compute the hypothenuse of two catheti (aka pythagoras)", () => {
-  const cat1 = 3
-  const cat2 = 4
-  const expectedResult = 5
-
-  expect(hypothenuse(cat1, cat2)).toBe(expectedResult)
-})