DiGraph

Instance Constructors

new DiGraph(edges: Map[T, Set[T]])

Create a new graph with the provided edge data
Create a new graph with the provided edge data
edges
a Map[T,Set[T]] of edge data For the edge data Map, the value associated with each vertex u in the graph is a Set[T] of nodes where for each node v in the set, the directed edge (u,v) exists in the graph.

Type Members

class CyclicException extends Exception

An exception that is raised when an assumed DAG has a cycle
class PathNotFoundException extends Exception

An exception that is raised when attempting to find an unreachable node

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def BFS(root: T): Map[T, T]

Performs breadth-first search on the directed graph
Performs breadth-first search on the directed graph
root
the start node
returns
a Map[T,T] from each visited node to its predecessor in the traversal
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def contains(v: T): Boolean

Check whether the graph contains vertex v
Check whether the graph contains vertex v

Definition Classes
DiGraph → DiGraphLike
val edges: Map[T, Set[T]]

a Map[T,Set[T]] of edge data For the edge data Map, the value associated with each vertex u in the graph is a Set[T] of nodes where for each node v in the set, the directed edge (u,v) exists in the graph.
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def findSCCs: Seq[Seq[T]]

Finds the strongly connected components in the graph
Finds the strongly connected components in the graph
returns
a Seq of Seq[T], each containing nodes of an SCC in traversable order
def findSinks: Set[T]

Find all sinks in the graph
Find all sinks in the graph
returns
a Set[T] of sink nodes
def findSources: Set[T]

Find all sources in the graph
Find all sources in the graph
returns
a Set[T] of source nodes
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getEdges(v: T): Set[T]

Get all edges of a node
Get all edges of a node
v
the specified node
returns
a Set[T] of all vertices that v has edges to

Definition Classes
DiGraph → DiGraphLike
def getVertices: Set[T]

Get all vertices in the graph
Get all vertices in the graph
returns
a Set[T] of all vertices in the graph

Definition Classes
DiGraph → DiGraphLike
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def linearize: Seq[T]

Linearizes (topologically sorts) a DAG
Linearizes (topologically sorts) a DAG
returns
a Map[T,T] from each visited node to its predecessor in the traversal

Exceptions thrown
CyclicException if the graph is cyclic
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def path(start: T, end: T): Seq[T]

Finds a path (if one exists) from one node to another
Finds a path (if one exists) from one node to another
start
the start node
end
the destination node
returns
a Seq[T] of nodes defining an arbitrary valid path

Exceptions thrown
def pathsInDAG(start: T): Map[T, Seq[Seq[T]]]

Finds all paths starting at a particular node in a DAG
Finds all paths starting at a particular node in a DAG
WARNING: This is an exponential time algorithm (as any algorithm must be for this problem), but is useful for flattening circuit graph hierarchies. Each path is represented by a Seq[T] of nodes in a traversable order.
start
the node to start at
returns
a Map[T,Seq[Seq[T]]] where the value associated with v is the Seq of all paths from start to v
def reachableFrom(root: T): Set[T]

Finds the set of nodes reachable from a particular node
Finds the set of nodes reachable from a particular node
root
the start node
returns
a Set[T] of nodes reachable from the root
def reverse: DiGraph[T]

Returns a graph with all edges reversed
def simplify(vprime: Set[T]): DiGraph[T]

Return a graph with only a subset of the nodes
Return a graph with only a subset of the nodes
Any path between two non-deleted nodes (u,v) that traverses only deleted nodes will be transformed into an edge (u,v).
vprime
the Set[T] of desired vertices
returns
the simplified graph

Exceptions thrown
IllegalArgumentException if vprime is not a subset of V
def subgraph(vprime: Set[T]): DiGraph[T]

Return a graph with only a subset of the nodes
Return a graph with only a subset of the nodes
Any edge including a deleted node will be deleted
vprime
the Set[T] of desired vertices
returns
the subgraph

Exceptions thrown
IllegalArgumentException if vprime is not a subset of V
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def transformNodes[Q](f: (T) ⇒ Q): DiGraph[Q]

Return a graph with all the nodes of the current graph transformed by a function.
Return a graph with all the nodes of the current graph transformed by a function. Edge connectivity will be the same as the current graph.
f
A function {(T) => Q} that transforms each node
returns
a transformed DiGraph[Q]
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object DiGraph | package graph

class DiGraph[T] extends DiGraphLike[T]

Instance Constructors

new DiGraph(edges: Map[T, Set[T]])

Type Members

class CyclicException extends Exception

class PathNotFoundException extends Exception

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def BFS(root: T): Map[T, T]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def contains(v: T): Boolean

val edges: Map[T, Set[T]]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

def findSCCs: Seq[Seq[T]]

def findSinks: Set[T]

def findSources: Set[T]

final def getClass(): Class[_]

def getEdges(v: T): Set[T]

def getVertices: Set[T]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def linearize: Seq[T]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def path(start: T, end: T): Seq[T]

def pathsInDAG(start: T): Map[T, Seq[Seq[T]]]

def reachableFrom(root: T): Set[T]

def reverse: DiGraph[T]

def simplify(vprime: Set[T]): DiGraph[T]

def subgraph(vprime: Set[T]): DiGraph[T]

final def synchronized[T0](arg0: ⇒ T0): T0

def toString(): String

def transformNodes[Q](f: (T) ⇒ Q): DiGraph[Q]

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

Inherited from DiGraphLike[T]

Inherited from AnyRef

Inherited from Any

Ungrouped