updating types

Author: GaelGil

src/services/graphAlgorithms/astar.ts

@@ -1,37 +1,51 @@
-import { PriorityQueue } from './datastructures/priorityQueue';
-import { getNeighbors, heuristic, exists } from './helper';
+import { PriorityQueue } from "./datastructures/priorityQueue";
+import { getNeighbors, heuristic, exists } from "./helper";
 
-export function ASTAR(grid, start, destination) {
-    let priorityQueue = new PriorityQueue(); // prioirty queue with lowest cost priority
-    priorityQueue.enqueue({ node: start, path: [start], cost: heuristic(start, destination), gcost: 0}); // add start node with cost being heuristic value
-    let expanded = []; // expanded nodes (nodes that weve checked all neighbors)
+export function ASTAR(grid: any[][], start: number[], destination: number[]) {
+  let priorityQueue = new PriorityQueue(); // prioirty queue with lowest cost priority
+  priorityQueue.enqueue({
+    node: start,
+    path: [start],
+    cost: heuristic(start, destination),
+    gcost: 0,
+  }); // add start node with cost being heuristic value
+  let expanded = []; // expanded nodes (nodes that weve checked all neighbors)
 
-    while (!priorityQueue.isEmpty()) {
-        let { node, path, cost, gcost } = priorityQueue.dequeue(); // get the node, its path, and cost from the front of the priority queue
-        if (node.toString() === destination.toString()) { // if node is destination 
-            return { status: "found", path, cost, expanded }; // return found, path, cost, and expanded. 
-        }
+  while (!priorityQueue.isEmpty()) {
+    let { node, path, cost, gcost } = priorityQueue.dequeue(); // get the node, its path, and cost from the front of the priority queue
+    if (node.toString() === destination.toString()) {
+      // if node is destination
+      return { status: "found", path, cost, expanded }; // return found, path, cost, and expanded.
+    }
 
-        if (exists(expanded, node)){ // if we have already expanded this node continue
-            continue; 
-        }
+    if (exists(expanded, node)) {
+      // if we have already expanded this node continue
+      continue;
+    }
 
-        let neighbors = getNeighbors(grid, node); // get neighbors of current node
-        for (let i = 0; i < neighbors.length; i++){ // for all neighbors
-            let neighbor = neighbors[i]; // select neighbor
-            if (grid[neighbor[0]][neighbor[1]] !== "w") { // if not a wall
-                let costToNeighbor = 1; // set cost to neighbor as 1
-                if (grid[neighbor[0]][neighbor[1]] === 'e'){ // if weighted 
-                    costToNeighbor = 5; // set weight cost 5
-                }
-                let g = gcost + costToNeighbor; // add up total cost actual to neighbor node (cost to current node + cost of neighbor)
-                let f = g + heuristic(neighbor, destination); // f = g (total cost to node) + heuristic
-                priorityQueue.enqueue({ node: neighbor, path: path.concat([neighbor]), cost: f, gcost: g}); // add neihhbor, path, fcost, and gcost
-            }
+    let neighbors = getNeighbors(grid, node); // get neighbors of current node
+    for (let i = 0; i < neighbors.length; i++) {
+      // for all neighbors
+      let neighbor = neighbors[i]; // select neighbor
+      if (grid[neighbor[0]][neighbor[1]] !== "w") {
+        // if not a wall
+        let costToNeighbor = 1; // set cost to neighbor as 1
+        if (grid[neighbor[0]][neighbor[1]] === "e") {
+          // if weighted
+          costToNeighbor = 5; // set weight cost 5
         }
-        expanded.push(node); // add to expanded list
-
+        let g = gcost + costToNeighbor; // add up total cost actual to neighbor node (cost to current node + cost of neighbor)
+        let f = g + heuristic(neighbor, destination); // f = g (total cost to node) + heuristic
+        priorityQueue.enqueue({
+          node: neighbor,
+          path: path.concat([neighbor]),
+          cost: f,
+          gcost: g,
+        }); // add neihhbor, path, fcost, and gcost
+      }
     }
+    expanded.push(node); // add to expanded list
+  }
 
-    return { status: "not found", path: [], cost: 0 };
-}
+  return { status: "not found", path: [], cost: 0 };
+}

src/services/graphAlgorithms/bfs.ts

@@ -1,33 +1,35 @@
-import { getNeighbors } from './helper';
+import { getNeighbors } from "./helper";
 
-export function BFS(grid, start, destination) {
-    let queue = [{ node: start, path: [start] }];
-    let visited = {};
-    let expanded = [];
+export function BFS(grid: any[][], start: number[], destination: number[]) {
+  let queue: any[] = [{ node: start, path: [start] }];
+  let visited: Record<string, boolean> = {};
+  let expanded = [];
 
-    while (queue) {
-        let { node, path } = queue.shift(); // get the node and its path from the front of the queue
-        let current_node_key = node.toString(); // to string for comparison
+  while (queue) {
+    let { node, path } = queue.shift(); // get the node and its path from the front of the queue
+    let current_node_key = node.toString(); // to string for comparison
 
-        if (current_node_key === destination.toString()) { // check if we have arrived at the solution
-            return { status: "found", path , expanded};
-        } 
+    if (current_node_key === destination.toString()) {
+      // check if we have arrived at the solution
+      return { status: "found", path, expanded };
+    }
+
+    if (visited.hasOwnProperty(current_node_key)) {
+      // if we have not been to this node, add it
+      continue;
+    }
+    visited[current_node_key] = true; // mark as visited
 
-        if (visited.hasOwnProperty(current_node_key)) { // if we have not been to this node, add it
-            continue;
-        }
-        visited[current_node_key] = true; // mark as visited
-        
-        let neighbors = getNeighbors(grid, node); // get neighbors of the current node
-        for (let i = 0; i < neighbors.length; i++) {
-            let neighbor = neighbors[i]; 
-            if (!(grid[neighbor[0]][neighbor[1]] === "w")) { // if there is no wall 
-                queue.push({ node: neighbor, path: path.concat([neighbor]) }); // add to end of queue
-                expanded.push(neighbor); // add the expanded node to the list
-            }
-               
-        }
+    let neighbors = getNeighbors(grid, node); // get neighbors of the current node
+    for (let i = 0; i < neighbors.length; i++) {
+      let neighbor = neighbors[i];
+      if (!(grid[neighbor[0]][neighbor[1]] === "w")) {
+        // if there is no wall
+        queue.push({ node: neighbor, path: path.concat([neighbor]) }); // add to end of queue
+        expanded.push(neighbor); // add the expanded node to the list
+      }
     }
+  }
 
-    return { status: "not found", path: [], expanded};
-}
+  return { status: "not found", path: [], expanded };
+}

src/services/graphAlgorithms/dfs.ts

@@ -1,33 +1,35 @@
-import { getNeighbors } from './helper';
+import { getNeighbors } from "./helper";
 
-export function DFS(grid, start, destination) {
-    let stack = [{ node: start, path: [start] }];
-    let visited = {};
-    let expanded = [];
+export function DFS(grid: any[][], start: number[], destination: number[]) {
+  let stack: any[] = [{ node: start, path: [start] }];
+  let visited: Record<string, boolean> = {};
+  let expanded = [];
 
-    while (stack) {
-        let { node, path } = stack.shift(); // get the node and its path from the front of the stack
-        let current_node_key = node.toString(); // to string for comparison
+  while (stack) {
+    let { node, path } = stack.shift(); // get the node and its path from the front of the stack
+    let current_node_key = node.toString(); // to string for comparison
 
-        if (current_node_key === destination.toString()) { // check if we have arrived at the solution
-            return { status: "found", path , expanded};
-        } 
+    if (current_node_key === destination.toString()) {
+      // check if we have arrived at the solution
+      return { status: "found", path, expanded };
+    }
 
-        if (visited.hasOwnProperty(current_node_key)) { // if we have not been to this node, add it
-            continue;
-        }
-        visited[current_node_key] = true; // mark as visited
+    if (visited.hasOwnProperty(current_node_key)) {
+      // if we have not been to this node, add it
+      continue;
+    }
+    visited[current_node_key] = true; // mark as visited
 
-        let neighbors = getNeighbors(grid, node); // get neighbors of the current node
-        for (let i = 0; i < neighbors.length; i++) {
-            let neighbor = neighbors[i]; 
-            if (!(grid[neighbor[0]][neighbor[1]] === "w")) { // if there is no wall
-                stack.unshift({ node: neighbor, path: path.concat([neighbor]) }); // add to beggining of stack
-                expanded.push(neighbor); // add the expanded node to the list
-            }
-        }
-            
+    let neighbors = getNeighbors(grid, node); // get neighbors of the current node
+    for (let i = 0; i < neighbors.length; i++) {
+      let neighbor = neighbors[i];
+      if (!(grid[neighbor[0]][neighbor[1]] === "w")) {
+        // if there is no wall
+        stack.unshift({ node: neighbor, path: path.concat([neighbor]) }); // add to beggining of stack
+        expanded.push(neighbor); // add the expanded node to the list
+      }
     }
+  }
 
-    return { status: "not found", path: [], expanded};
-}
+  return { status: "not found", path: [], expanded };
+}

src/services/graphAlgorithms/helper.ts

@@ -1,76 +1,77 @@
-function isValidIndex(matrix, i, j) {
-    return i >= 0 && i < matrix.length && j >= 0 && j < matrix[0].length;
+function isValidIndex(matrix: any[][], i: number, j: number) {
+  return i >= 0 && i < matrix.length && j >= 0 && j < matrix[0].length;
 }
 
+export function getNeighbors(matrix: any[][], current_node: number[]) {
+  let neighbors = [];
+  let i = current_node[0];
+  let j = current_node[1];
 
-export function getNeighbors(matrix, current_node) {
-    let neighbors = []
-    let i = current_node[0];
-    let j = current_node[1];
-    
-    // top neihgbor
-    if (isValidIndex(matrix, i - 1, j)) {
-        neighbors.push([i - 1, j]);
-    }
+  // top neihgbor
+  if (isValidIndex(matrix, i - 1, j)) {
+    neighbors.push([i - 1, j]);
+  }
 
-    // bottom neighbor
-    if (isValidIndex(matrix, i + 1, j)) {
-        neighbors.push([i + 1, j]);
-    }
+  // bottom neighbor
+  if (isValidIndex(matrix, i + 1, j)) {
+    neighbors.push([i + 1, j]);
+  }
 
-    // left neighbor
-    if (isValidIndex(matrix, i, j - 1)) {
-        neighbors.push([i, j-1]);
-    }
+  // left neighbor
+  if (isValidIndex(matrix, i, j - 1)) {
+    neighbors.push([i, j - 1]);
+  }
 
-    // right neighbor
-    if (isValidIndex(matrix, i, j + 1)) {
-        neighbors.push([i, j+1]);
-    }
+  // right neighbor
+  if (isValidIndex(matrix, i, j + 1)) {
+    neighbors.push([i, j + 1]);
+  }
 
-    return neighbors;
+  return neighbors;
 }
 
-
-  // function to check for conflict
-export function conflict(i, j, maze){
-    // index checking
-    if (i < 0 || i >= maze.length || j < 0 || j >= maze[0].length) { 
-        return false;
-    }
-
-
-    if (maze[i][j] === 'w' || maze[i][j] === 'e' || maze[i][j] === 'o' || maze[i][j] === 's'){
-        return true;
-    }
-
-    // if objective is surronded by obstacles
-  
-        if (
-            (i > 0 && maze[i - 1][j] === "w") ||
-            (i < maze.length - 1 && maze[i + 1][j] === "w") ||
-            (j > 0 && maze[i][j - 1] === "w") ||
-            (j < maze[0].length - 1 && maze[i][j + 1] === "w")
-        ) {
-            return true;
-        }
-    
+// function to check for conflict
+export function conflict(i: number, j: number, maze: any[][]) {
+  // index checking
+  if (i < 0 || i >= maze.length || j < 0 || j >= maze[0].length) {
     return false;
   }
 
+  if (
+    maze[i][j] === "w" ||
+    maze[i][j] === "e" ||
+    maze[i][j] === "o" ||
+    maze[i][j] === "s"
+  ) {
+    return true;
+  }
+
+  // if objective is surronded by obstacles
+  if (
+    (i > 0 && maze[i - 1][j] === "w") ||
+    (i < maze.length - 1 && maze[i + 1][j] === "w") ||
+    (j > 0 && maze[i][j - 1] === "w") ||
+    (j < maze[0].length - 1 && maze[i][j + 1] === "w")
+  ) {
+    return true;
+  }
 
-export function heuristic(node, destination){
-    return (Math.abs(node[0]-destination[0]) + Math.abs(node[1]-destination[1]));
+  return false;
 }
 
+export function heuristic(node: number[], destination: number[]) {
+  return (
+    Math.abs(node[0] - destination[0]) + Math.abs(node[1] - destination[1])
+  );
+}
 
 export function exists(list_, node) {
-    const nodeString = JSON.stringify(node);
-    return list_.some(item => JSON.stringify(item) === nodeString);
+  const nodeString = JSON.stringify(node);
+  return list_.some((item) => JSON.stringify(item) === nodeString);
 }
 
-export function randInts(min, max) {
+export function randInts(min: number, max: number) {
   min = Math.ceil(min);
   max = Math.floor(max);
   return Math.floor(Math.random() * (max - min + 1)) + min;
-}
+}