quiver

Graph

case class Graph[N, A, B](rep: GraphRep[N, A, B]) extends Product with Serializable

An implementation of an inductive graph where nodes of type N are labeled with A, and edges are labeled with B.

Linear Supertypes
Serializable, Serializable, Product, Equals, AnyRef, Any
Ordering
  1. Grouped
  2. Alphabetic
  3. By inheritance
Inherited
  1. Graph
  2. Serializable
  3. Serializable
  4. Product
  5. Equals
  6. AnyRef
  7. Any
Implicitly
  1. by any2stringadd
  2. by any2stringfmt
  3. by any2ArrowAssoc
  4. by any2Ensuring
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Instance Constructors

  1. new Graph(rep: GraphRep[N, A, B])

Value Members

  1. final def !=(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  2. final def !=(arg0: Any): Boolean

    Definition Classes
    Any

  3. final def ##(): Int

    Definition Classes
    AnyRef → Any

  4. def &(ctx: Context[N, A, B]): Graph[N, A, B]

    Alias for embed

  5. def +(other: String): String

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to StringAdd performed by method any2stringadd in scala.Predef.
    Definition Classes
    StringAdd

  6. def ->[B](y: B): (Graph[N, A, B], B)

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to ArrowAssoc[Graph[N, A, B]] performed by method any2ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc
    Annotations
    @inline()

  7. final def ==(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  8. final def ==(arg0: Any): Boolean

    Definition Classes
    Any

  9. def addEdge(e: LEdge[N, B]): Graph[N, A, B]

    Add an edge to this graph.

    Add an edge to this graph. Throws an error if the source and target nodes don't exist in the graph.

  10. def addEdges(es: Seq[LEdge[N, B]]): Graph[N, A, B]

    Add multiple edges to this graph

  11. def addNode(n: LNode[N, A]): Graph[N, A, B]

    Add a node to this graph.

    Add a node to this graph. If this node already exists with a different label, its label will be replaced with this new one.

  12. def addNodes(vs: Seq[LNode[N, A]]): Graph[N, A, B]

    Add multiple nodes to this graph

  13. final def asInstanceOf[T0]: T0

    Definition Classes
    Any

  14. def bf(q: Queue[Path[N]]): RTree[N]

    Utility function for breadth-first search trees.

  15. def bfe(v: N): Seq[Edge[N]]

    Breadth-first search remembering predecessor information.

    Breadth-first search remembering predecessor information. Gives transient edges in breadth-first order, starting from the given node.

  16. def bfen(es: Seq[Edge[N]]): Seq[Edge[N]]

    Breadth-first search remembering predecessor information.

    Breadth-first search remembering predecessor information. Gives transient edges starting from the targets of the given edges, in breadth-first order.

  17. def bfenInternal(q: Queue[Edge[N]]): Vector[Edge[N]]

    Utility function for breadth-first search, remembering predecessor information.

  18. def bfs(v: N): Seq[N]

    Breadth-first search from the given node.

    Breadth-first search from the given node. The result is ordered by distance from the node v.

  19. def bfsWith[C](f: (Context[N, A, B]) ⇒ C, v: N): Seq[C]

    Breadth-first search from the given node.

    Breadth-first search from the given node. The result is a vector of results of passing the context of each visited to the function f.

  20. def bfsn(vs: Seq[N]): Seq[N]

    Breadth-first search from the given nodes.

    Breadth-first search from the given nodes. The result is the successors of vs, with immediate successors first.

  21. def bfsnInternal[C](f: (Context[N, A, B]) ⇒ C, q: Queue[N]): Vector[C]

    Utility function for breadth-first search (nodes ordered by distance)

  22. def bfsnWith[C](f: (Context[N, A, B]) ⇒ C, vs: Seq[N]): Seq[C]

    Breadth-first search from the given nodes.

    Breadth-first search from the given nodes. The result is a vector of results of passing the context of each visited node to the function f.

  23. def bft(v: N): RTree[N]

    Breadth-first search tree.

    Breadth-first search tree. The result is a list of paths through the graph from the given vertex, in breadth-first order.

  24. def bidecomp(first: N, last: N): Option[BiDecomp[N, A, B]]

    Returns a context focused on two nodes designated "first" and "last", if present, and the graph with those nodes removed.

  25. def clone(): AnyRef

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  26. def contains(v: N): Boolean

    Returns true if the given node is in the graph, otherwise false

  27. def context(v: N): Context[N, A, B]

    Find the context for the given node.

    Find the context for the given node. Causes an error if the node is not present in the graph.

  28. def contextGraph: Graph[N, Context[N, A, B], B]

    Get all the contexts of this graph, as a graph.

  29. def contexts: Vector[Context[N, A, B]]

    Get all the contexts in the graph, as a vector.

    Get all the contexts in the graph, as a vector. Note that the resulting contexts may overlap, in the sense that successive contexts in the result will contain vertices from previous contexts as well.

  30. def countNodes: Int

    The number of nodes in this graph

  31. def decomp(n: N): Decomp[N, A, B]

    Returns a context focused on the given node, if present, and the graph with that node removed.

  32. def decompAny: Decomp[N, A, B]

    Decompose this graph into the context for an arbitrarily chosen node and the rest of the graph.

  33. def degree(v: N): Int

    The number of connections to and from the given node

  34. def dff(vs: Seq[N]): Vector[Tree[N]]

    Depth-first forest.

    Depth-first forest. Follows successors of the given nodes. The result is a vector of trees of nodes where each path in each tree is a path through the graph.

  35. def dffWith[C](vs: Seq[N], f: (Context[N, A, B]) ⇒ C): Vector[Tree[C]]

    Depth-first forest.

    Depth-first forest. Follows successors of the given nodes. The result is a vector of trees of results of passing the context of each node to the function f.

  36. def dfs(vs: Seq[N]): Seq[N]

    Forward depth-first search.

  37. def dfsWith[C](vs: Seq[N], f: (Context[N, A, B]) ⇒ C): Seq[C]

    Forward depth-first search.

  38. def edges: Vector[Edge[N]]

    A list of all the edges in the graph

  39. def efilter(f: (LEdge[N, B]) ⇒ Boolean): Graph[N, A, B]

    The subgraph containing only edges that match the property

  40. def elfilter(f: (B) ⇒ Boolean): Graph[N, A, B]

    The subgraph containing only edges whose labels match the property

  41. def emap[C](f: (B) ⇒ C): Graph[N, A, C]

    Map a function over the edge labels in the graph

  42. def embed(ctx: Context[N, A, B]): Graph[N, A, B]

    Embed the given context in the graph.

    Embed the given context in the graph. If the context's vertex is already in the graph, removes the old context from the graph first. This operation is the deterministic inverse of decomp and obeys the following laws:

    (g & c) decomp c.vertex == Decomp(Some(c), g) (g decomp c.vertex).rest & c == (g & c)

  43. def endBy(f: (Graph[N, A, B], N) ⇒ Seq[N]): Seq[N]

    Find all nodes that match the given ending criteria.

  44. def endNode(f: (Graph[N, A, B], N) ⇒ Seq[N], n: N): Boolean

    Check if the given node is an end node according to the given criteria.

    Check if the given node is an end node according to the given criteria. An ending node n in graph g has f(g,n) containing no nodes other than n.

  45. def ensuring(cond: (Graph[N, A, B]) ⇒ Boolean, msg: ⇒ Any): Graph[N, A, B]

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to Ensuring[Graph[N, A, B]] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  46. def ensuring(cond: (Graph[N, A, B]) ⇒ Boolean): Graph[N, A, B]

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to Ensuring[Graph[N, A, B]] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  47. def ensuring(cond: Boolean, msg: ⇒ Any): Graph[N, A, B]

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to Ensuring[Graph[N, A, B]] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  48. def ensuring(cond: Boolean): Graph[N, A, B]

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to Ensuring[Graph[N, A, B]] performed by method any2Ensuring in scala.Predef.
    Definition Classes
    Ensuring

  49. final def eq(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  50. def esp(s: N, t: N): Option[Path[N]]

    The shortest path from vertex s to vertex t

  51. def filterMap[C, D](f: (Context[N, A, B]) ⇒ Option[Context[N, C, D]]): Graph[N, C, D]

    Build a graph out of a partial map of the contexts in this graph.

  52. def finalize(): Unit

    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws( classOf[java.lang.Throwable] )

  53. def findEdge(e: Edge[N]): Option[LEdge[N, B]]

    Find an edge between two nodes

  54. def fold[C](u: C)(f: (Context[N, A, B], C) ⇒ C): C

    Fold a function over the graph.

    Fold a function over the graph. Note that each successive context received by the function will not contain vertices at the focus of previously received contexts. The first context will be an arbitrarily chosen context of this graph, but the next context will be arbitrarily chosen from a graph with the first context removed, and so on.

  55. def foldAll[C](u: C)(f: (Context[N, A, B], C) ⇒ C): C

    Fold a function over all the contexts in the graph.

    Fold a function over all the contexts in the graph. Each context received by the function will be an arbitrarily chosen context of this graph. Contrary to fold, this visits every node of the graph and gives you all incoming and outgoing adjacencies for each node.

  56. def formatted(fmtstr: String): String

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to StringFormat performed by method any2stringfmt in scala.Predef.
    Definition Classes
    StringFormat
    Annotations
    @inline()

  57. final def getClass(): Class[_]

    Definition Classes
    AnyRef → Any

  58. def gmap[C, D](f: (Context[N, A, B]) ⇒ Context[N, C, D]): Graph[N, C, D]

    Map a function over the graph

  59. def hasLoop: Boolean

    Check if this graph has any loops, which connect a node to itself.

  60. def hasMulti: Boolean

    Check if this graph has multiple edges connecting any two nodes

  61. def inDegree(v: N): Int

    The number of inbound edges from the given node

  62. def inEdges(v: N): Vector[LEdge[N, B]]

    Find all inbound edges for the given node

  63. def ins(v: N): Adj[N, B]

    All the inbound links of the given node, including self-edges

  64. def isEmpty: Boolean

    Check if the graph is empty

  65. final def isInstanceOf[T0]: Boolean

    Definition Classes
    Any

  66. def isLeaf(n: N): Boolean

    Check if the given node is a leaf of this graph

  67. def isRoot(n: N): Boolean

    Check if the given node is a root of this graph

  68. def isSimple: Boolean

    Check whether this graph is simple.

    Check whether this graph is simple. A simple graph has no loops and no multi-edges.

  69. def labEdges: Vector[LEdge[N, B]]

    A list of all the edges in the graph and their labels

  70. def labNodes: Vector[LNode[N, A]]

    A list of all the nodes in the graph and their labels

  71. def label(v: N): Option[A]

    Find the label for a node

  72. def labfilter(p: (A) ⇒ Boolean): Graph[N, A, B]

    The subgraph containing only nodes whose labels match the property

  73. def labnfilter(p: (LNode[N, A]) ⇒ Boolean): Graph[N, A, B]

    The subgraph containing only labelled nodes that match the property

  74. def lbf(q: Queue[LPath[N, B]]): LRTree[N, B]

    Utility function for labeled breadth-first search tree

  75. def lbft(v: N): LRTree[N, B]

    Breadth-first search tree with labeled paths

  76. def leaves: Set[N]

    Find the leaves of the graph.

    Find the leaves of the graph. A leaf is a node which as no outgoing edges.

  77. def lesp(s: N, t: N): Option[LPath[N, B]]

    Shortest path from vertex s to vertex t, with labels

  78. def level(v: N): Seq[(N, Int)]

    Breadth-first search giving the distance of each node from the node v.

  79. def leveln(vs: Seq[(N, Int)]): Seq[(N, Int)]

    Breadth-first search giving the distance of each node from the search nodes.

  80. final def ne(arg0: AnyRef): Boolean

    Definition Classes
    AnyRef

  81. def neighbors(v: N): Vector[N]

    Find the neighbors of a node

  82. def nfilter(p: (N) ⇒ Boolean): Graph[N, A, B]

    The subgraph containing only nodes that match the property

  83. def nmap[C](f: (A) ⇒ C): Graph[N, C, B]

    Map a function over the node labels in the graph

  84. def nodes: Vector[N]

    A list of all the nodes in the graph

  85. final def notify(): Unit

    Definition Classes
    AnyRef

  86. final def notifyAll(): Unit

    Definition Classes
    AnyRef

  87. def outDegree(v: N): Int

    The number of outbound edges from the given node

  88. def outEdges(v: N): Vector[LEdge[N, B]]

    Find all outbound edges for the given node

  89. def outs(v: N): Adj[N, B]

    All the outbound links of the given node, including self-edges

  90. def predecessors(v: N): Vector[N]

    Find all nodes that have a link to the given node

  91. def rdfs(vs: Seq[N]): Seq[N]

    Reverse depth-first search.

    Reverse depth-first search. Follows predecessors.

  92. def reachable(v: N): Vector[N]

    Finds all the reachable nodes from a given node, using DFS

  93. def redecorate[C](f: (Context[N, A, B]) ⇒ C): Graph[N, C, B]

    Map a function over the contexts of this graph, and put the results in the labels.

  94. def removeEdge(e: Edge[N]): Graph[N, A, B]

    Remove an edge from this graph

  95. def removeEdges(es: Seq[Edge[N]]): Graph[N, A, B]

    Remove multiple edges from this graph

  96. def removeLEdge(e: LEdge[N, B]): Graph[N, A, B]

    Remove an edge from this graph only if the label matches

  97. def removeNode(v: N): Graph[N, A, B]

    Remove a node from this graph

  98. def removeNodes(vs: Seq[N]): Graph[N, A, B]

    Remove multiple nodes from this graph

  99. val rep: GraphRep[N, A, B]

  100. def reverse: Graph[N, A, B]

    Reverse the direction of all edges

  101. def roots: Set[N]

    Find the roots of the graph.

    Find the roots of the graph. A root is a node which has no incoming edges.

  102. def safeAddEdge(e: LEdge[N, B], failover: ⇒ Graph[N, A, B] = this): Graph[N, A, B]

    Add an edge to this graph.

    Add an edge to this graph. If the source and target nodes don't exist in this graph, return the given failover graph.

  103. def safeAddEdges(es: Seq[LEdge[N, B]]): Graph[N, A, B]

    Add multiple edges to this graph, ignoring edges whose source and target nodes don't already exist in the graph.

  104. def select(p: (Context[N, A, B]) ⇒ Boolean): Vector[Context[N, A, B]]

    Project out (non-overlapping) contexts for which the given property is true.

    Project out (non-overlapping) contexts for which the given property is true. Note that the contexts will not overlap, in the sense that successive contexts in the result will not contain the vertices at the focus of previous contexts.

  105. def selectAll(p: (Context[N, A, B]) ⇒ Boolean): Vector[Context[N, A, B]]

    Get all the contexts for which the given property is true.

    Get all the contexts for which the given property is true. Note that the resulting contexts may overlap, in the sense that successive contexts in the result may contain vertices from previous contexts.

  106. def subgraph(vs: Seq[N]): Graph[N, A, B]

    The subgraph containing only the given nodes

  107. def successors(v: N): Vector[N]

    Find all nodes that have a link from the given node

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

    Definition Classes
    AnyRef

  109. def tclose: Graph[N, A, Unit]

    Finds the transitive closure of this graph.

  110. def toString(): String

    Definition Classes
    Graph → AnyRef → Any

  111. def udfs(vs: Seq[N]): Seq[N]

    Undirected depth-first search

  112. def undir: Graph[N, A, B]

    Make the graph undirected, ensuring that every edge has an inverse.

    Make the graph undirected, ensuring that every edge has an inverse. This takes edge labels into account when considering whether two edges are equal.

  113. def union(g: Graph[N, A, B]): Graph[N, A, B]

    Adds all the nodes and edges from one graph to another.

  114. def unlabel: Graph[N, Unit, Unit]

    Erase all labels in the graph

  115. def updateEdge(e: LEdge[N, B]): Graph[N, A, B]

    Replace an edge with a new one

  116. def updateEdges(es: Seq[LEdge[N, B]]): Graph[N, A, B]

    Update multiple edges

  117. def updateNode(n: LNode[N, A]): Graph[N, A, B]

    Replace a node with a new one

  118. def updateNodes(ns: Seq[LNode[N, A]]): Graph[N, A, B]

    Update multiple nodes

  119. def vmap[M](f: (N) ⇒ M): Graph[M, A, B]

    Map over the unique node identifiers in the graph

  120. final def wait(): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

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

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  122. final def wait(arg0: Long): Unit

    Definition Classes
    AnyRef
    Annotations
    @throws( ... )

  123. def xdfWith[C](vs: Seq[N], d: (Context[N, A, B]) ⇒ Seq[N], f: (Context[N, A, B]) ⇒ C): (Vector[Tree[C]], Graph[N, A, B])

    Generalized depth-first forest.

    Generalized depth-first forest. Uses the function d to decide which nodes to visit next

  124. def xdffWith[C](vs: Seq[N], d: (Context[N, A, B]) ⇒ Seq[N], f: (Context[N, A, B]) ⇒ C): Vector[Tree[C]]

    Generalized depth-first forest.

    Generalized depth-first forest. Uses the function d to decide which nodes to visit next.

  125. final def xdfsWith[C](vs: Seq[N], d: (Context[N, A, B]) ⇒ Seq[N], f: (Context[N, A, B]) ⇒ C): Vector[C]

    Generalized depth-first search.

  126. def →[B](y: B): (Graph[N, A, B], B)

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to ArrowAssoc[Graph[N, A, B]] performed by method any2ArrowAssoc in scala.Predef.
    Definition Classes
    ArrowAssoc

Shadowed Implicit Value Members

  1. val self: Any

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to StringAdd performed by method any2stringadd in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (graph: StringAdd).self
    Definition Classes
    StringAdd

  2. val self: Any

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to StringFormat performed by method any2stringfmt in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (graph: StringFormat).self
    Definition Classes
    StringFormat

Deprecated Value Members

  1. def x: Graph[N, A, B]

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to ArrowAssoc[Graph[N, A, B]] performed by method any2ArrowAssoc in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (graph: ArrowAssoc[Graph[N, A, B]]).x
    Definition Classes
    ArrowAssoc
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use leftOfArrow instead

  2. def x: Graph[N, A, B]

    Implicit information
    This member is added by an implicit conversion from Graph[N, A, B] to Ensuring[Graph[N, A, B]] performed by method any2Ensuring in scala.Predef.
    Shadowing
    This implicitly inherited member is ambiguous. One or more implicitly inherited members have similar signatures, so calling this member may produce an ambiguous implicit conversion compiler error.
    To access this member you can use a type ascription:
    (graph: Ensuring[Graph[N, A, B]]).x
    Definition Classes
    Ensuring
    Annotations
    @deprecated
    Deprecated

    (Since version 2.10.0) Use resultOfEnsuring instead

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AnyRef

Inherited from Any

Inherited by implicit conversion any2stringadd from Graph[N, A, B] to StringAdd

Inherited by implicit conversion any2stringfmt from Graph[N, A, B] to StringFormat

Inherited by implicit conversion any2ArrowAssoc from Graph[N, A, B] to ArrowAssoc[Graph[N, A, B]]

Inherited by implicit conversion any2Ensuring from Graph[N, A, B] to Ensuring[Graph[N, A, B]]

Basic Graph Operations

Graph Decomposition

Structural decomposition of a graph

Graph Composition

Deletion and Modification

Projection

Functions for extracting global information about a graph

Graph Inspection

Functions for extracting information about individual nodes and edges in a graph

Folds and Maps

Subgraphs

Depth-First Search

Algorithms for depth-first traversal.

Breadth-First Search

Algorithms for breadth-first traversal.

Roots and Leaves

Queries to find starting and ending nodes, roots, and leaves.

Graph Classification

Classification functions on graphs

Ungrouped