brep-io-kernel 1.0.209 → 1.0.211

package/src/wireHarness/pathFinderLogic/js/digraphs/spt_old.js

@@ -1,118 +0,0 @@
-// Created on the base of the project:
-// https://github.com/noamsauerutley/shortest-path
-
-// MIT License
-
-// Copyright 2020 © Noam Sauer-Utley. https://www.noamsauerutley.com/
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-
-class ShortestPathTree {
-  constructor(graph) {
-    if (!graph)
-      throw "No graph passed: " + graph;
-    this.graph = graph;
-    this.startNode = null;
-    this.parents = {};
-    this.distances = {};
-    this.numberOfNodes = Object.entries(graph).length;
-  }
-
-  build(startNode) {
-    if (!this.graph[startNode])
-      throw "No start node '" + startNode + "'";
-    this.startNode = startNode;
-    this.distances = {};
-    this.distances = Object.assign(this.distances, this.graph[startNode]);
-
-    this.parents = {};
-    // track paths
-    for (const child in this.graph[startNode]) {
-      this.parents[child] = startNode;
-    }
-
-    // track nodes that have already been visited
-    const visited = [];
-
-    // find the nearest node
-    let node = this.shortestDistanceNode(visited);
-
-    // for that node
-    while (node) {
-      // find its distance from the start node & its child nodes
-      const distance = this.distances[node];
-      const children = this.graph[node];
-      // for each of those child nodes
-      for (const child in children) {
-        // make sure each child node is not the start node
-        if (String(child) === String(startNode)) {
-          continue;
-        }
-        // save the distance from the start node to the child node
-        const newdistance = distance + children[child];
-        // if there's no recorded distance from the start node to the child node in the distances object
-        // or if the recorded distance is shorter than the previously stored distance from the start node to the child node
-        // save the distance to the object
-        // record the path
-        if (!this.distances[child] || this.distances[child] > newdistance) {
-          this.distances[child] = newdistance;
-          this.parents[child] = node;
-        }
-      }
-      // move the node to the visited set
-      visited.push(node);
-      // move to the nearest neighbor node
-      node = this.shortestDistanceNode(visited);
-    }
-  }
-
-  getShortestPath(endNode) {
-    if (!this.graph[endNode])
-      throw "No end node '" + endNode + "'";
-    let parent = this.parents[endNode];
-    if (parent == null) {
-      return null;
-    }
-    const shortestPath = [endNode];
-    while (parent) {
-      shortestPath.push(parent);
-      parent = this.parents[parent];
-    }
-    shortestPath.reverse();
-    return shortestPath;
-  }
-
-  // private
-  shortestDistanceNode(visited) {
-    let shortest = null;
-
-    for (const node in this.distances) {
-      const currentIsShortest =
-        shortest === null || this.distances[node] < this.distances[shortest];
-      if (currentIsShortest && !visited.includes(node)) {
-        shortest = node;
-      }
-    }
-    return shortest;
-  }
-}
-
-
-

package/src/wireHarness/pathFinderLogic/js/heap/min_heap_original.js

@@ -1,83 +0,0 @@
-// See https://blog.bitsrc.io/implementing-heaps-in-javascript-c3fbf1cb2e65
-class MinHeap {
-
-  constructor() {
-    /* Initialing the array heap and adding a dummy element at index 0 */
-    this.heap = [null]
-  }
-
-  getMin() {
-    /* Accessing the min element at index 1 in the heap array */
-    return this.heap[1]
-  }
-
-  insert(node) {
-
-    /* Inserting the new node at the end of the heap array */
-    this.heap.push(node)
-
-    /* Finding the correct position for the new node */
-
-    if (this.heap.length > 1) {
-      let current = this.heap.length - 1
-
-      /* Traversing up the parent node until the current node (current) is greater than the parent (current/2)*/
-      while (current > 1 && this.heap[Math.floor(current / 2)] > this.heap[current]) {
-
-        /* Swapping the two nodes by using the ES6 destructuring syntax*/
-        [this.heap[Math.floor(current / 2)], this.heap[current]] = [this.heap[current], this.heap[Math.floor(current / 2)]]
-        current = Math.floor(current / 2)
-      }
-    }
-  }
-
-  remove() {
-    /* Smallest element is at the index 1 in the heap array */
-    const smallest = this.heap[1]
-
-    /* When there are more than two elements in the array, we put the right most element at the first position
-        and start comparing nodes with the child nodes
-    */
-    if (this.heap.length > 2) {
-      this.heap[1] = this.heap[this.heap.length - 1]
-      this.heap.splice(this.heap.length - 1)
-
-      if (this.heap.length === 3) {
-        if (this.heap[1] > this.heap[2]) {
-          [this.heap[1], this.heap[2]] = [this.heap[2], this.heap[1]]
-        }
-        return smallest
-      }
-
-      let current = 1
-      let leftChildIndex = current * 2
-      let rightChildIndex = current * 2 + 1
-
-      while (this.heap[leftChildIndex] &&
-      this.heap[rightChildIndex] &&
-      (this.heap[current] > this.heap[leftChildIndex] ||
-        this.heap[current] > this.heap[rightChildIndex])) {
-        if (this.heap[leftChildIndex] < this.heap[rightChildIndex]) {
-          [this.heap[current], this.heap[leftChildIndex]] = [this.heap[leftChildIndex], this.heap[current]]
-          current = leftChildIndex
-        } else {
-          [this.heap[current], this.heap[rightChildIndex]] = [this.heap[rightChildIndex], this.heap[current]]
-          current = rightChildIndex
-        }
-
-        leftChildIndex = current * 2
-        rightChildIndex = current * 2 + 1
-      }
-    }
-
-    /* If there are only two elements in the array, we directly splice out the first element */
-
-    else if (this.heap.length === 2) {
-      this.heap.splice(1, 1)
-    } else {
-      return null
-    }
-
-    return smallest
-  }
-}