@inglorious/engine 0.1.1 → 0.2.0

package/src/utils/algorithms/path-finding.js

@@ -1,155 +1,155 @@
-/**
- * @typedef {import("./types").Node} Node
- * @typedef {import("./types").Graph} Graph
- */
-
-import {
-  contains,
-  push,
-  remove,
-  root,
-} from "@inglorious/utils/data-structures/heap.js"
-import { abs, magnitude } from "@inglorious/utils/math/linear-algebra/vector.js"
-import { subtract } from "@inglorious/utils/math/linear-algebra/vectors.js"
-
-const NO_COST = 0
-
-/**
- * Calculates the cost of a path using Dijkstra's algorithm.
- * In this simplified form the cost is simply 0.
- *
- * @returns {number} - The cost of the path (which is 0).
- */
-export const dijkstra = () => NO_COST
-
-/**
- * Calculates the Euclidean distance between two nodes.
- *
- * @param {Node} a - The first node.
- * @param {Node} b - The second node.
- * @returns {number} - The Euclidean distance between the two nodes.
- */
-export const eucledianDistance = (a, b) =>
-  magnitude(subtract(a.position, b.position))
-
-/**
- * Calculates the Manhattan distance between two nodes.
- *
- * @param {Node} a - The first node.
- * @param {Node} b - The second node.
- * @returns {number} - The Manhattan distance between the two nodes.
- */
-export const manhattanDistance = (a, b) => abs(subtract(a.position, b.position))
-
-/**
- * Compares the cost of two nodes.
- *
- * @param {Node} a - The first node.
- * @param {Node} b - The second node.
- * @returns {number} - The difference in cost between the two nodes.
- */
-const compareCost = (a, b) => b.cost - a.cost
-
-/**
- * Compares the total cost of two nodes.
- *
- * @param {Node} a - The first node.
- * @param {Node} b - The second node.
- * @returns {number} - The difference in total cost between the two nodes.
- */
-const compareTotalCost = (a, b) => b.totalCost - a.totalCost
-
-/**
- * Finds the shortest path in a graph from a start node to an end node using a heuristic.
- *
- * @param {Graph} graph - The graph containing nodes and arcs.
- * @param {string} start - The ID of the start node.
- * @param {string} end - The ID of the end node.
- * @param {(a: Node, b: Node) => number} [heuristic=eucledianDistance] - The heuristic function to estimate the cost.
- * @returns {string[]} - An array of node IDs representing the shortest path.
- */
-export function findPath(graph, start, end, heuristic = eucledianDistance) {
-  const { nodes, arcs } = adaptGraph(graph)
-  const findNode = createFindNode(nodes)
-
-  const startNode = findNode(start)
-  const endNode = findNode(end)
-  let discoveredNodes = [startNode]
-  let evaluatedNodes = []
-  let path = []
-
-  while (discoveredNodes.length) {
-    let current = root(discoveredNodes, compareTotalCost)
-
-    if (current.id === end) {
-      while (current != null) {
-        path = [current.id, ...path]
-        current = current.previous
-      }
-
-      return path
-    }
-
-    discoveredNodes = remove(discoveredNodes, current)
-    evaluatedNodes = push(evaluatedNodes, current)
-
-    const outgoingArcs = arcs.filter(({ from }) => from === current.id)
-    const destinations = outgoingArcs.map(({ to }) => findNode(to))
-
-    for (const destination of destinations) {
-      const totalCost =
-        current.cost +
-        destination.cost +
-        heuristic(current, destination) +
-        outgoingArcs.find(({ to }) => to === destination.id)?.cost
-
-      let isNewPathFound = false
-      if (contains(discoveredNodes, destination)) {
-        if (totalCost < destination.cost) {
-          destination.cost = totalCost
-          isNewPathFound = true
-        }
-      } else {
-        destination.cost = totalCost
-        isNewPathFound = true
-        discoveredNodes = push(discoveredNodes, destination, compareCost)
-      }
-
-      if (isNewPathFound) {
-        destination.totalCost =
-          destination.cost + heuristic(destination, endNode)
-        destination.previous = current
-      }
-    }
-  }
-}
-
-/**
- * Adapts a graph to ensure all nodes and arcs have a cost property.
- *
- * @param {Graph} graph - The graph to adapt.
- * @returns {Graph} - The adapted graph with cost properties added.
- */
-function adaptGraph(graph) {
-  return {
-    ...graph,
-    nodes: Array.isArray(graph.nodes)
-      ? graph.nodes.map((node) => ({ ...node, cost: node.cost ?? NO_COST }))
-      : Object.entries(graph.nodes).map(([key, value]) => ({
-          id: key,
-          position: value,
-          cost: 0,
-        })),
-    arcs: graph.arcs.map((arc) => ({ ...arc, cost: arc.cost ?? NO_COST })),
-  }
-}
-
-/**
- * Creates a function that finds a node by its ID.
- *
- * @param {Node[]} nodes - The array of nodes.
- * @returns {(id: string) => Node} - A function that finds a node by its ID.
- */
-function createFindNode(nodes) {
-  return (id) => nodes.find((node) => node.id === id)
-}
+/**
+ * @typedef {import("./types").Node} Node
+ * @typedef {import("./types").Graph} Graph
+ */
+
+import {
+  contains,
+  push,
+  remove,
+  root,
+} from "@inglorious/utils/data-structures/heap.js"
+import { abs, magnitude } from "@inglorious/utils/math/linear-algebra/vector.js"
+import { subtract } from "@inglorious/utils/math/linear-algebra/vectors.js"
+
+const NO_COST = 0
+
+/**
+ * Calculates the cost of a path using Dijkstra's algorithm.
+ * In this simplified form the cost is simply 0.
+ *
+ * @returns {number} - The cost of the path (which is 0).
+ */
+export const dijkstra = () => NO_COST
+
+/**
+ * Calculates the Euclidean distance between two nodes.
+ *
+ * @param {Node} a - The first node.
+ * @param {Node} b - The second node.
+ * @returns {number} - The Euclidean distance between the two nodes.
+ */
+export const eucledianDistance = (a, b) =>
+  magnitude(subtract(a.position, b.position))
+
+/**
+ * Calculates the Manhattan distance between two nodes.
+ *
+ * @param {Node} a - The first node.
+ * @param {Node} b - The second node.
+ * @returns {number} - The Manhattan distance between the two nodes.
+ */
+export const manhattanDistance = (a, b) => abs(subtract(a.position, b.position))
+
+/**
+ * Compares the cost of two nodes.
+ *
+ * @param {Node} a - The first node.
+ * @param {Node} b - The second node.
+ * @returns {number} - The difference in cost between the two nodes.
+ */
+const compareCost = (a, b) => b.cost - a.cost
+
+/**
+ * Compares the total cost of two nodes.
+ *
+ * @param {Node} a - The first node.
+ * @param {Node} b - The second node.
+ * @returns {number} - The difference in total cost between the two nodes.
+ */
+const compareTotalCost = (a, b) => b.totalCost - a.totalCost
+
+/**
+ * Finds the shortest path in a graph from a start node to an end node using a heuristic.
+ *
+ * @param {Graph} graph - The graph containing nodes and arcs.
+ * @param {string} start - The ID of the start node.
+ * @param {string} end - The ID of the end node.
+ * @param {(a: Node, b: Node) => number} [heuristic=eucledianDistance] - The heuristic function to estimate the cost.
+ * @returns {string[]} - An array of node IDs representing the shortest path.
+ */
+export function findPath(graph, start, end, heuristic = eucledianDistance) {
+  const { nodes, arcs } = adaptGraph(graph)
+  const findNode = createFindNode(nodes)
+
+  const startNode = findNode(start)
+  const endNode = findNode(end)
+  let discoveredNodes = [startNode]
+  let evaluatedNodes = []
+  let path = []
+
+  while (discoveredNodes.length) {
+    let current = root(discoveredNodes, compareTotalCost)
+
+    if (current.id === end) {
+      while (current != null) {
+        path = [current.id, ...path]
+        current = current.previous
+      }
+
+      return path
+    }
+
+    discoveredNodes = remove(discoveredNodes, current)
+    evaluatedNodes = push(evaluatedNodes, current)
+
+    const outgoingArcs = arcs.filter(({ from }) => from === current.id)
+    const destinations = outgoingArcs.map(({ to }) => findNode(to))
+
+    for (const destination of destinations) {
+      const totalCost =
+        current.cost +
+        destination.cost +
+        heuristic(current, destination) +
+        outgoingArcs.find(({ to }) => to === destination.id)?.cost
+
+      let isNewPathFound = false
+      if (contains(discoveredNodes, destination)) {
+        if (totalCost < destination.cost) {
+          destination.cost = totalCost
+          isNewPathFound = true
+        }
+      } else {
+        destination.cost = totalCost
+        isNewPathFound = true
+        discoveredNodes = push(discoveredNodes, destination, compareCost)
+      }
+
+      if (isNewPathFound) {
+        destination.totalCost =
+          destination.cost + heuristic(destination, endNode)
+        destination.previous = current
+      }
+    }
+  }
+}
+
+/**
+ * Adapts a graph to ensure all nodes and arcs have a cost property.
+ *
+ * @param {Graph} graph - The graph to adapt.
+ * @returns {Graph} - The adapted graph with cost properties added.
+ */
+function adaptGraph(graph) {
+  return {
+    ...graph,
+    nodes: Array.isArray(graph.nodes)
+      ? graph.nodes.map((node) => ({ ...node, cost: node.cost ?? NO_COST }))
+      : Object.entries(graph.nodes).map(([key, value]) => ({
+          id: key,
+          position: value,
+          cost: 0,
+        })),
+    arcs: graph.arcs.map((arc) => ({ ...arc, cost: arc.cost ?? NO_COST })),
+  }
+}
+
+/**
+ * Creates a function that finds a node by its ID.
+ *
+ * @param {Node[]} nodes - The array of nodes.
+ * @returns {(id: string) => Node} - A function that finds a node by its ID.
+ */
+function createFindNode(nodes) {
+  return (id) => nodes.find((node) => node.id === id)
+}

package/src/utils/algorithms/path-finding.test.js

@@ -1,151 +1,151 @@
-import {
-  createBoard,
-  down,
-  downRight,
-  right,
-} from "@inglorious/utils/data-structures/board.js"
-import { expect, test } from "vitest"
-
-import { findPath } from "./path-finding.js"
-
-test("it should find the shortest path in a trivial example", () => {
-  const graph = {
-    nodes: {
-      A: [0, 0],
-      B: [2, 0],
-    },
-    arcs: [{ from: "A", to: "B", cost: 2 }],
-  }
-  const start = "A"
-  const end = "B"
-  const expectedResult = ["A", "B"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
-
-test("it should find the shortest path between two nodes with default heuristic", () => {
-  const graph = {
-    nodes: {
-      A: [0, 0],
-      B: [2, 0],
-      C: [3, 2],
-      D: [4, 4],
-      E: [1, 1],
-      F: [2, 3],
-      G: [0, 4],
-    },
-    arcs: [
-      { from: "A", to: "B" },
-      { from: "B", to: "C" },
-      { from: "C", to: "D" },
-      { from: "A", to: "E" },
-      { from: "E", to: "F" },
-      { from: "F", to: "G" },
-      { from: "G", to: "D" },
-    ],
-  }
-  const start = "A"
-  const end = "D"
-  const expectedResult = ["A", "B", "C", "D"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
-
-test("it should find the shortest path between two nodes with node costs", () => {
-  const graph = {
-    nodes: [
-      { id: "A", position: [0, 0], cost: 0 },
-      { id: "B", position: [2, 0], cost: 7 },
-      { id: "C", position: [3, 2], cost: 3 },
-      { id: "D", position: [4, 4], cost: 2 },
-      { id: "E", position: [1, 1], cost: 1.5 },
-      { id: "F", position: [2, 3], cost: 2 },
-      { id: "G", position: [0, 4], cost: 3 },
-    ],
-    arcs: [
-      { from: "A", to: "B" },
-      { from: "B", to: "C" },
-      { from: "C", to: "D" },
-      { from: "A", to: "E" },
-      { from: "E", to: "F" },
-      { from: "F", to: "G" },
-      { from: "G", to: "D" },
-    ],
-  }
-  const start = "A"
-  const end = "D"
-  const expectedResult = ["A", "E", "F", "G", "D"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
-
-test("it should find the shortest path between two nodes with arc costs", () => {
-  const graph = {
-    nodes: {
-      A: [0, 0],
-      B: [2, 0],
-      C: [3, 2],
-      D: [4, 4],
-      E: [1, 1],
-      F: [2, 3],
-      G: [0, 4],
-    },
-    arcs: [
-      { from: "A", to: "B", cost: 7 },
-      { from: "B", to: "C", cost: 3 },
-      { from: "C", to: "D", cost: 2 },
-      { from: "A", to: "E", cost: 1.5 },
-      { from: "E", to: "F", cost: 2 },
-      { from: "F", to: "G", cost: 3 },
-      { from: "G", to: "D", cost: 4 },
-    ],
-  }
-  const start = "A"
-  const end = "D"
-  const expectedResult = ["A", "E", "F", "G", "D"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
-
-test("it should find the best path in a board graph", () => {
-  const rows = 5
-  const columns = 5
-  const size = [rows, columns]
-  const filler = (i, j) => ({ id: `${i}${j}`, position: [i, j] })
-  const board = createBoard(size, filler)
-
-  const graph = {
-    nodes: board,
-    arcs: [],
-  }
-
-  for (let i = 0; i < rows; i++) {
-    for (let j = 0; j < columns; j++) {
-      const current = `${i}${j}`
-      if (i + 1 < rows) {
-        graph.arcs.push({
-          from: current,
-          to: down([i, j], size).join(""),
-        })
-      }
-      if (j + 1 < columns) {
-        graph.arcs.push({
-          from: current,
-          to: right([i, j], size).join(""),
-        })
-      }
-      if (i + 1 < rows && j + 1 < columns) {
-        graph.arcs.push({
-          from: current,
-          to: downRight([i, j], size).join(""),
-        })
-      }
-    }
-  }
-
-  const start = "00"
-  const end = "44"
-  const expectedResult = ["00", "11", "22", "33", "44"]
-
-  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
-})
+import {
+  createBoard,
+  down,
+  downRight,
+  right,
+} from "@inglorious/utils/data-structures/board.js"
+import { expect, test } from "vitest"
+
+import { findPath } from "./path-finding.js"
+
+test("it should find the shortest path in a trivial example", () => {
+  const graph = {
+    nodes: {
+      A: [0, 0],
+      B: [2, 0],
+    },
+    arcs: [{ from: "A", to: "B", cost: 2 }],
+  }
+  const start = "A"
+  const end = "B"
+  const expectedResult = ["A", "B"]
+
+  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
+})
+
+test("it should find the shortest path between two nodes with default heuristic", () => {
+  const graph = {
+    nodes: {
+      A: [0, 0],
+      B: [2, 0],
+      C: [3, 2],
+      D: [4, 4],
+      E: [1, 1],
+      F: [2, 3],
+      G: [0, 4],
+    },
+    arcs: [
+      { from: "A", to: "B" },
+      { from: "B", to: "C" },
+      { from: "C", to: "D" },
+      { from: "A", to: "E" },
+      { from: "E", to: "F" },
+      { from: "F", to: "G" },
+      { from: "G", to: "D" },
+    ],
+  }
+  const start = "A"
+  const end = "D"
+  const expectedResult = ["A", "B", "C", "D"]
+
+  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
+})
+
+test("it should find the shortest path between two nodes with node costs", () => {
+  const graph = {
+    nodes: [
+      { id: "A", position: [0, 0], cost: 0 },
+      { id: "B", position: [2, 0], cost: 7 },
+      { id: "C", position: [3, 2], cost: 3 },
+      { id: "D", position: [4, 4], cost: 2 },
+      { id: "E", position: [1, 1], cost: 1.5 },
+      { id: "F", position: [2, 3], cost: 2 },
+      { id: "G", position: [0, 4], cost: 3 },
+    ],
+    arcs: [
+      { from: "A", to: "B" },
+      { from: "B", to: "C" },
+      { from: "C", to: "D" },
+      { from: "A", to: "E" },
+      { from: "E", to: "F" },
+      { from: "F", to: "G" },
+      { from: "G", to: "D" },
+    ],
+  }
+  const start = "A"
+  const end = "D"
+  const expectedResult = ["A", "E", "F", "G", "D"]
+
+  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
+})
+
+test("it should find the shortest path between two nodes with arc costs", () => {
+  const graph = {
+    nodes: {
+      A: [0, 0],
+      B: [2, 0],
+      C: [3, 2],
+      D: [4, 4],
+      E: [1, 1],
+      F: [2, 3],
+      G: [0, 4],
+    },
+    arcs: [
+      { from: "A", to: "B", cost: 7 },
+      { from: "B", to: "C", cost: 3 },
+      { from: "C", to: "D", cost: 2 },
+      { from: "A", to: "E", cost: 1.5 },
+      { from: "E", to: "F", cost: 2 },
+      { from: "F", to: "G", cost: 3 },
+      { from: "G", to: "D", cost: 4 },
+    ],
+  }
+  const start = "A"
+  const end = "D"
+  const expectedResult = ["A", "E", "F", "G", "D"]
+
+  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
+})
+
+test("it should find the best path in a board graph", () => {
+  const rows = 5
+  const columns = 5
+  const size = [rows, columns]
+  const filler = (i, j) => ({ id: `${i}${j}`, position: [i, j] })
+  const board = createBoard(size, filler)
+
+  const graph = {
+    nodes: board,
+    arcs: [],
+  }
+
+  for (let i = 0; i < rows; i++) {
+    for (let j = 0; j < columns; j++) {
+      const current = `${i}${j}`
+      if (i + 1 < rows) {
+        graph.arcs.push({
+          from: current,
+          to: down([i, j], size).join(""),
+        })
+      }
+      if (j + 1 < columns) {
+        graph.arcs.push({
+          from: current,
+          to: right([i, j], size).join(""),
+        })
+      }
+      if (i + 1 < rows && j + 1 < columns) {
+        graph.arcs.push({
+          from: current,
+          to: downRight([i, j], size).join(""),
+        })
+      }
+    }
+  }
+
+  const start = "00"
+  const end = "44"
+  const expectedResult = ["00", "11", "22", "33", "44"]
+
+  expect(findPath(graph, start, end)).toStrictEqual(expectedResult)
+})