directed-graph-typed 1.39.6 → 1.41.0

package/src/data-structures/binary-tree/segment-tree.ts

@@ -9,70 +9,18 @@
 import type {SegmentTreeNodeVal} from '../../types';
 
 export class SegmentTreeNode {
-  constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null) {
-    this._start = start;
-    this._end = end;
-    this._sum = sum;
-    this._value = value || null;
-  }
-
-  private _start = 0;
-  get start(): number {
-    return this._start;
-  }
-
-  set start(v: number) {
-    this._start = v;
-  }
-
-  private _end = 0;
-
-  get end(): number {
-    return this._end;
-  }
-
-  set end(v: number) {
-    this._end = v;
-  }
-
-  private _value: SegmentTreeNodeVal | null = null;
-
-  get value(): SegmentTreeNodeVal | null {
-    return this._value;
-  }
-
-  set value(v: SegmentTreeNodeVal | null) {
-    this._value = v;
-  }
-
-  private _sum = 0;
+  start = 0;
+  end = 0;
+  value: SegmentTreeNodeVal | null = null;
+  sum = 0;
+  left: SegmentTreeNode | null = null;
+  right: SegmentTreeNode | null = null;
 
-  get sum(): number {
-    return this._sum;
-  }
-
-  set sum(v: number) {
-    this._sum = v;
-  }
-
-  private _left: SegmentTreeNode | null = null;
-
-  get left(): SegmentTreeNode | null {
-    return this._left;
-  }
-
-  set left(v: SegmentTreeNode | null) {
-    this._left = v;
-  }
-
-  private _right: SegmentTreeNode | null = null;
-
-  get right(): SegmentTreeNode | null {
-    return this._right;
-  }
-
-  set right(v: SegmentTreeNode | null) {
-    this._right = v;
+  constructor(start: number, end: number, sum: number, value?: SegmentTreeNodeVal | null) {
+    this.start = start;
+    this.end = end;
+    this.sum = sum;
+    this.value = value || null;
   }
 }
 
@@ -101,24 +49,25 @@ export class SegmentTree {
     }
   }
 
-  private _values: number[] = [];
+  protected _values: number[] = [];
 
   get values(): number[] {
     return this._values;
   }
 
-  private _start = 0;
+  protected _start = 0;
+
   get start(): number {
     return this._start;
   }
 
-  private _end: number;
+  protected _end: number;
 
   get end(): number {
     return this._end;
   }
 
-  private _root: SegmentTreeNode | null;
+  protected _root: SegmentTreeNode | null;
 
   get root(): SegmentTreeNode | null {
     return this._root;
@@ -238,20 +187,4 @@ export class SegmentTree {
     };
     return dfs(root, indexA, indexB);
   }
-
-  protected _setValues(value: number[]) {
-    this._values = value;
-  }
-
-  protected _setStart(value: number) {
-    this._start = value;
-  }
-
-  protected _setEnd(value: number) {
-    this._end = value;
-  }
-
-  protected _setRoot(v: SegmentTreeNode | null) {
-    this._root = v;
-  }
 }

package/src/data-structures/binary-tree/tree-multiset.ts

@@ -6,7 +6,7 @@
  * @license MIT License
  */
 import type {BTNKey, TreeMultisetNodeNested, TreeMultisetOptions} from '../../types';
-import {BinaryTreeDeletedResult, CP, FamilyPosition, IterationType, BTNCallback} from '../../types';
+import {BinaryTreeDeletedResult, BTNCallback, CP, FamilyPosition, IterationType} from '../../types';
 import {IBinaryTree} from '../../interfaces';
 import {AVLTree, AVLTreeNode} from './avl-tree';
 
@@ -37,8 +37,7 @@ export class TreeMultisetNode<
  */
 export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultisetNode<V, TreeMultisetNodeNested<V>>>
   extends AVLTree<V, N>
-  implements IBinaryTree<V, N>
-{
+  implements IBinaryTree<V, N> {
   /**
    * The constructor function for a TreeMultiset class in TypeScript, which extends another class and sets an option to
    * merge duplicated values.
@@ -93,7 +92,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
     }
     if (!this.root) {
       this._setRoot(newNode);
-      this._setSize(this.size + 1);
+      this._size = this.size + 1;
       newNode && this._setCount(this.count + newNode.count);
       inserted = this.root;
     } else {
@@ -113,7 +112,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
               if (cur.left === undefined) {
                 //Add to the left of the current node
                 cur.left = newNode;
-                this._setSize(this.size + 1);
+                this._size = this.size + 1;
                 this._setCount(this.count + newNode.count);
 
                 traversing = false;
@@ -127,7 +126,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
               if (cur.right === undefined) {
                 //Add to the right of the current node
                 cur.right = newNode;
-                this._setSize(this.size + 1);
+                this._size = this.size + 1;
                 this._setCount(this.count + newNode.count);
 
                 traversing = false;
@@ -162,7 +161,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
       if (parent.left === undefined) {
         parent.left = newNode;
         if (newNode !== null) {
-          this._setSize(this.size + 1);
+          this._size = this.size + 1;
           this._setCount(this.count + newNode.count);
         }
 
@@ -170,7 +169,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
       } else if (parent.right === undefined) {
         parent.right = newNode;
         if (newNode !== null) {
-          this._setSize(this.size + 1);
+          this._size = (this.size + 1);
           this._setCount(this.count + newNode.count);
         }
         return parent.right;
@@ -321,7 +320,7 @@ export class TreeMultiset<V = any, N extends TreeMultisetNode<V, N> = TreeMultis
           }
         }
       }
-      this._setSize(this.size - 1);
+      this._size = this.size - 1;
       // TODO How to handle when the count of target node is lesser than current node's count
       this._setCount(this.count - orgCurrent.count);
     }

package/src/data-structures/graph/abstract-graph.ts

@@ -12,6 +12,9 @@ import {IGraph} from '../../interfaces';
 import {Queue} from '../queue';
 
 export abstract class AbstractVertex<V = any> {
+  key: VertexKey;
+  value: V | undefined;
+
   /**
    * The function is a protected constructor that takes an key and an optional value as parameters.
    * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex. It is
@@ -20,32 +23,16 @@ export abstract class AbstractVertex<V = any> {
    * vertex. If no value is provided, it will be set to undefined.
    */
   protected constructor(key: VertexKey, value?: V) {
-    this._key = key;
-    this._value = value;
-  }
-
-  private _key: VertexKey;
-
-  get key(): VertexKey {
-    return this._key;
-  }
-
-  set key(v: VertexKey) {
-    this._key = v;
-  }
-
-  private _value: V | undefined;
-
-  get value(): V | undefined {
-    return this._value;
+    this.key = key;
+    this.value = value;
   }
 
-  set value(value: V | undefined) {
-    this._value = value;
-  }
 }
 
 export abstract class AbstractEdge<E = any> {
+  value: E | undefined;
+  weight: number;
+
   /**
    * The above function is a protected constructor that initializes the weight, value, and hash code properties of an
    * object.
@@ -56,31 +43,11 @@ export abstract class AbstractEdge<E = any> {
    * meaning it can be omitted when creating an instance of the class.
    */
   protected constructor(weight?: number, value?: E) {
-    this._weight = weight !== undefined ? weight : 1;
-    this._value = value;
+    this.weight = weight !== undefined ? weight : 1;
+    this.value = value;
     this._hashCode = uuidV4();
   }
 
-  private _value: E | undefined;
-
-  get value(): E | undefined {
-    return this._value;
-  }
-
-  set value(value: E | undefined) {
-    this._value = value;
-  }
-
-  private _weight: number;
-
-  get weight(): number {
-    return this._weight;
-  }
-
-  set weight(v: number) {
-    this._weight = v;
-  }
-
   protected _hashCode: string;
 
   get hashCode(): string {
@@ -91,15 +58,6 @@ export abstract class AbstractEdge<E = any> {
    * In TypeScript, a subclass inherits the interface implementation of its parent class, without needing to implement the same interface again in the subclass. This behavior differs from Java's approach. In Java, if a parent class implements an interface, the subclass needs to explicitly implement the same interface, even if the parent class has already implemented it.
    * This means that using abstract methods in the parent class cannot constrain the grandchild classes. Defining methods within an interface also cannot constrain the descendant classes. When inheriting from this class, developers need to be aware that this method needs to be overridden.
    */
-
-  /**
-   * The function sets the value of the _hashCode property to the provided string.
-   * @param {string} v - The parameter "v" is of type string and represents the value that will be assigned to the
-   * "_hashCode" property.
-   */
-  protected _setHashCode(v: string) {
-    this._hashCode = v;
-  }
 }
 
 export abstract class AbstractGraph<
@@ -107,9 +65,8 @@ export abstract class AbstractGraph<
   E = any,
   VO extends AbstractVertex<V> = AbstractVertex<V>,
   EO extends AbstractEdge<E> = AbstractEdge<E>
-> implements IGraph<V, E, VO, EO>
-{
-  private _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
+> implements IGraph<V, E, VO, EO> {
+  protected _vertices: Map<VertexKey, VO> = new Map<VertexKey, VO>();
 
   get vertices(): Map<VertexKey, VO> {
     return this._vertices;
@@ -556,14 +513,14 @@ export abstract class AbstractGraph<
     }
 
     getMinDist &&
-      distMap.forEach((d, v) => {
-        if (v !== srcVertex) {
-          if (d < minDist) {
-            minDist = d;
-            if (genPaths) minDest = v;
-          }
+    distMap.forEach((d, v) => {
+      if (v !== srcVertex) {
+        if (d < minDist) {
+          minDist = d;
+          if (genPaths) minDest = v;
         }
-      });
+      }
+    });
 
     genPaths && getPaths(minDest);
 
@@ -625,7 +582,7 @@ export abstract class AbstractGraph<
       if (vertexOrKey instanceof AbstractVertex) distMap.set(vertexOrKey, Infinity);
     }
 
-    const heap = new PriorityQueue<{key: number; value: VO}>({comparator: (a, b) => a.key - b.key});
+    const heap = new PriorityQueue<{ key: number; value: VO }>({comparator: (a, b) => a.key - b.key});
     heap.add({key: 0, value: srcVertex});
 
     distMap.set(srcVertex, 0);
@@ -854,7 +811,7 @@ export abstract class AbstractGraph<
    * `predecessor` property is a 2D array of vertices (or `null`) representing the predecessor vertices in the shortest
    * path between vertices in the
    */
-  floyd(): {costs: number[][]; predecessor: (VO | null)[][]} {
+  floyd(): { costs: number[][]; predecessor: (VO | null)[][] } {
     const idAndVertices = [...this._vertices];
     const n = idAndVertices.length;
 
@@ -1040,7 +997,4 @@ export abstract class AbstractGraph<
     return vertexOrKey instanceof AbstractVertex ? vertexOrKey.key : vertexOrKey;
   }
 
-  protected _setVertices(value: Map<VertexKey, VO>) {
-    this._vertices = value;
-  }
 }

package/src/data-structures/graph/directed-graph.ts

@@ -24,6 +24,9 @@ export class DirectedVertex<V = any> extends AbstractVertex<V> {
 }
 
 export class DirectedEdge<E = any> extends AbstractEdge<E> {
+  src: VertexKey;
+  dest: VertexKey;
+
   /**
    * The constructor function initializes the source and destination vertices of an edge, along with an optional weight
    * and value.
@@ -37,40 +40,19 @@ export class DirectedEdge<E = any> extends AbstractEdge<E> {
    */
   constructor(src: VertexKey, dest: VertexKey, weight?: number, value?: E) {
     super(weight, value);
-    this._src = src;
-    this._dest = dest;
-  }
-
-  private _src: VertexKey;
-
-  get src(): VertexKey {
-    return this._src;
-  }
-
-  set src(v: VertexKey) {
-    this._src = v;
-  }
-
-  private _dest: VertexKey;
-
-  get dest(): VertexKey {
-    return this._dest;
-  }
-
-  set dest(v: VertexKey) {
-    this._dest = v;
+    this.src = src;
+    this.dest = dest;
   }
 }
 
 export class DirectedGraph<
-    V = any,
-    E = any,
-    VO extends DirectedVertex<V> = DirectedVertex<V>,
-    EO extends DirectedEdge<E> = DirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends DirectedVertex<V> = DirectedVertex<V>,
+  EO extends DirectedEdge<E> = DirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor function initializes an instance of a class.
    */
@@ -78,13 +60,13 @@ export class DirectedGraph<
     super();
   }
 
-  private _outEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
+  protected _outEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
   get outEdgeMap(): Map<VO, EO[]> {
     return this._outEdgeMap;
   }
 
-  private _inEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
+  protected _inEdgeMap: Map<VO, EO[]> = new Map<VO, EO[]>();
 
   get inEdgeMap(): Map<VO, EO[]> {
     return this._inEdgeMap;
@@ -464,12 +446,4 @@ export class DirectedGraph<
       return false;
     }
   }
-
-  protected _setOutEdgeMap(value: Map<VO, EO[]>) {
-    this._outEdgeMap = value;
-  }
-
-  protected _setInEdgeMap(value: Map<VO, EO[]>) {
-    this._inEdgeMap = value;
-  }
 }

package/src/data-structures/graph/map-graph.ts

@@ -2,6 +2,9 @@ import {MapGraphCoordinate, VertexKey} from '../../types';
 import {DirectedEdge, DirectedGraph, DirectedVertex} from './directed-graph';
 
 export class MapVertex<V = any> extends DirectedVertex<V> {
+  lat: number;
+  long: number;
+
   /**
    * The constructor function initializes an object with an key, latitude, longitude, and an optional value.
    * @param {VertexKey} key - The `key` parameter is of type `VertexKey` and represents the identifier of the vertex.
@@ -16,28 +19,8 @@ export class MapVertex<V = any> extends DirectedVertex<V> {
    */
   constructor(key: VertexKey, value: V, lat: number, long: number) {
     super(key, value);
-    this._lat = lat;
-    this._long = long;
-  }
-
-  private _lat: number;
-
-  get lat(): number {
-    return this._lat;
-  }
-
-  set lat(value: number) {
-    this._lat = value;
-  }
-
-  private _long: number;
-
-  get long(): number {
-    return this._long;
-  }
-
-  set long(value: number) {
-    this._long = value;
+    this.lat = lat;
+    this.long = long;
   }
 }
 
@@ -78,26 +61,18 @@ export class MapGraph<
     this._bottomRight = bottomRight;
   }
 
-  private _origin: MapGraphCoordinate = [0, 0];
+  protected _origin: MapGraphCoordinate = [0, 0];
 
   get origin(): MapGraphCoordinate {
     return this._origin;
   }
 
-  set origin(value: MapGraphCoordinate) {
-    this._origin = value;
-  }
-
-  private _bottomRight: MapGraphCoordinate | undefined;
+  protected _bottomRight: MapGraphCoordinate | undefined;
 
   get bottomRight(): MapGraphCoordinate | undefined {
     return this._bottomRight;
   }
 
-  set bottomRight(value: MapGraphCoordinate | undefined) {
-    this._bottomRight = value;
-  }
-
   /**
    * The function creates a new vertex with the given key, value, latitude, and longitude.
    * @param {VertexKey} key - The key parameter is the unique identifier for the vertex. It is of type VertexKey, which could

package/src/data-structures/graph/undirected-graph.ts

@@ -24,6 +24,8 @@ export class UndirectedVertex<V = any> extends AbstractVertex<V> {
 }
 
 export class UndirectedEdge<E = number> extends AbstractEdge<E> {
+  vertices: [VertexKey, VertexKey];
+
   /**
    * The constructor function creates an instance of a class with two vertex IDs, an optional weight, and an optional
    * value.
@@ -36,29 +38,18 @@ export class UndirectedEdge<E = number> extends AbstractEdge<E> {
    */
   constructor(v1: VertexKey, v2: VertexKey, weight?: number, value?: E) {
     super(weight, value);
-    this._vertices = [v1, v2];
-  }
-
-  private _vertices: [VertexKey, VertexKey];
-
-  get vertices() {
-    return this._vertices;
-  }
-
-  set vertices(v: [VertexKey, VertexKey]) {
-    this._vertices = v;
+    this.vertices = [v1, v2];
   }
 }
 
 export class UndirectedGraph<
-    V = any,
-    E = any,
-    VO extends UndirectedVertex<V> = UndirectedVertex<V>,
-    EO extends UndirectedEdge<E> = UndirectedEdge<E>
-  >
+  V = any,
+  E = any,
+  VO extends UndirectedVertex<V> = UndirectedVertex<V>,
+  EO extends UndirectedEdge<E> = UndirectedEdge<E>
+>
   extends AbstractGraph<V, E, VO, EO>
-  implements IGraph<V, E, VO, EO>
-{
+  implements IGraph<V, E, VO, EO> {
   /**
    * The constructor initializes a new Map object to store edges.
    */
@@ -265,12 +256,4 @@ export class UndirectedGraph<
     }
     return true;
   }
-
-  /**
-   * The function sets the edges of a graph.
-   * @param v - A map where the keys are of type VO and the values are arrays of type EO.
-   */
-  protected _setEdges(v: Map<VO, EO[]>) {
-    this._edges = v;
-  }
 }

package/src/data-structures/hash/coordinate-map.ts

@@ -60,8 +60,4 @@ export class CoordinateMap<V> extends Map<any, V> {
   override delete(key: number[]) {
     return super.delete(key.join(this._joint));
   }
-
-  protected _setJoint(v: string) {
-    this._joint = v;
-  }
 }

package/src/data-structures/hash/coordinate-set.ts

@@ -49,8 +49,4 @@ export class CoordinateSet extends Set<any> {
   override delete(value: number[]) {
     return super.delete(value.join(this._joint));
   }
-
-  protected _setJoint(v: string) {
-    this._joint = v;
-  }
 }