Class Graph<T, U>

constructor

• new Graph<T = unknown, U = unknown>(directed: boolean): Graph<T, U>

  Type Parameters

  • T = unknown
  • U = unknown

  Parameters

  • directed: boolean

  Returns Graph<T, U>

Readonlydirected

addEdge

• addEdge(from: number, to: number, weight: U): number

  Parameters

  • from: number
  • to: number
  • weight: U

  Returns number

addEdgeUnchecked

• addEdgeUnchecked(from: number, to: number, weight: U): number

  Parameters

  • from: number
  • to: number
  • weight: U

  Returns number

addNode

• addNode(weight: T): number

  Parameters

  • weight: T

  Returns number

findEdgeId

• findEdgeId(from: number, to: number): number

  Parameters

  • from: number
  • to: number

  Returns number

forEachNeighbour

• forEachNeighbour(id: number, callback: (nodeId: number) => void): void

  Parameters

  • id: number
  • callback: (nodeId: number) => void

  Returns void

forEachNodeEdge

• forEachNodeEdge(id: number, callback: (edge: Edge<U>) => void): void

  Parameters

  • id: number
  • callback: (edge: Edge<U>) => void

  Returns void

getEdge

• getEdge(id: number): Edge<U>

  Parameters

  • id: number

  Returns Edge<U>

getEdgeCount

• getEdgeCount(): number

  Returns number

getEdges

• getEdges(): Edge<U>[]

  Returns Edge<U>[]

getEdgeWeight

• getEdgeWeight(id: number): U

  Parameters

  • id: number

  Returns U

getNode

• getNode(id: number): Node<T>

  Parameters

  • id: number

  Returns Node<T>

getNodeCount

• getNodeCount(): number

  Returns number

getNodes

• getNodes(): Node<T>[]

  Returns Node<T>[]

getNodeWeight

• getNodeWeight(id: number): T

  Parameters

  • id: number

  Returns T

hasEdge

• hasEdge(from: number, to: number): boolean

  Parameters

  • from: number
  • to: number

  Returns boolean

removeEdge

• removeEdge(id: number): boolean

  Parameters

  • id: number

  Returns boolean

removeNode

• removeNode(id: number): boolean

  Parameters

  • id: number

  Returns boolean

serialize

• serialize(): {
      directed: boolean;
      edges: { from: number; next: [number, number]; to: number; weight: U }[];
      nodes: { next: [number, number]; weight: T }[];
  }

  Returns {
      directed: boolean;
      edges: { from: number; next: [number, number]; to: number; weight: U }[];
      nodes: { next: [number, number]; weight: T }[];
  }

setEdgeWeight

• setEdgeWeight(id: number, weight: U): void

  Parameters

  • id: number
  • weight: U

  Returns void

setNodeWeight

• setNodeWeight(id: number, weight: T): void

  Parameters

  • id: number
  • weight: T

  Returns void

Staticdeserialize

• deserialize<T, U>(value: GraphSerial<T, U>, out?: Graph<T, U>): Graph<T, U>

  Type Parameters

  • T
  • U

  Parameters

  • value: GraphSerial<T, U>
  • Optionalout: Graph<T, U>

  Returns Graph<T, U>

Staticserialize

• serialize<T, U>(
      value: Graph<T, U>,
  ): {
      directed: boolean;
      edges: { from: number; next: [number, number]; to: number; weight: U }[];
      nodes: { next: [number, number]; weight: T }[];
  }

  Type Parameters

  • T
  • U

  Parameters

  • value: Graph<T, U>

  Returns {
      directed: boolean;
      edges: { from: number; next: [number, number]; to: number; weight: U }[];
      nodes: { next: [number, number]; weight: T }[];
  }

StaticvalidSerial

• validSerial<T, U>(value: unknown): value is GraphSerial<T, U>

  Type Parameters

  • T
  • U

  Parameters

  • value: unknown

  Returns value is GraphSerial<T, U>