quiver

package quiver

Linear Supertypes
AnyRef, Any
Ordering
  1. Grouped
  2. Alphabetic
  3. By inheritance
Inherited
  1. quiver
  2. AnyRef
  3. Any
  1. Hide All
  2. Show all
Learn more about member selection
Visibility
  1. Public
  2. All

Type Members

  1. type Adj[N, B] = Vector[(B, N)]

    Labeled links to or from a node

  2. case class BiDecomp[N, A, B](first: Context[N, A, B], last: Context[N, A, B], rest: Graph[N, A, B]) extends Product with Serializable

    The decomposition of a graph into two detached contexts focused on distinguished "first" and "last" nodes.

  3. case class Context[N, A, B](inAdj: Adj[N, B], vertex: N, label: A, outAdj: Adj[N, B]) extends Product with Serializable

    The view of a graph focused on the context surrounding a particular node.

  4. case class Decomp[N, A, B](ctx: Option[Context[N, A, B]], rest: Graph[N, A, B]) extends Product with Serializable

    The decomposition of a graph into possibly a detached context focused on one node, and the rest of the graph.

  5. case class Edge[N](from: N, to: N) extends Product with Serializable

  6. case class GDecomp[N, A, B](ctx: Context[N, A, B], rest: Graph[N, A, B]) extends Product with Serializable

    The decomposition of a graph into a detached context focused on one node, and the rest of the graph.

  7. case class GrContext[N, A, B](inAdj: Map[N, Set[B]], label: A, outAdj: Map[N, Set[B]]) extends Product with Serializable

    The label, predecessors, and successors of a given node

  8. 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.

  9. type GraphRep[N, A, B] = Map[N, GrContext[N, A, B]]

    The internal representation of a graph

  10. case class LEdge[N, A](from: N, to: N, label: A) extends Product with Serializable

  11. case class LNode[N, A](vertex: N, label: A) extends Product with Serializable

  12. type LPath[N, A] = Vector[(A, N)]

    Labeled path through a graph

  13. type LRTree[N, A] = Stream[LPath[N, A]]

    Inward directed tree as a list of labeled paths

  14. type Path[N] = Vector[N]

    Unlabeled path through a graph

  15. type RTree[N] = Stream[Path[N]]

    Inward directed tree as a list of paths

  16. type UEdge[N] = LEdge[N, Unit]

    Quasi-unlabaled edge

  17. type UNode[N] = LNode[N, Unit]

    Quasi-unlabeled node

Value Members

  1. object GDecomp extends Serializable

  2. def addPred[N, A, B](g: GraphRep[N, A, B], v: N, lss: Vector[(B, N)]): GraphRep[N, A, B]

  3. def addSucc[N, A, B](g: GraphRep[N, A, B], v: N, lps: Vector[(B, N)]): GraphRep[N, A, B]

  4. def banana(n: Int, k: Int): Graph[Int, Unit, Unit]

    Create an (n,k)-banana tree, which is an undirected graph obtained by connecting one leaf of each of n copies of a k-star graph with a single root vertex that is distinct from all the stars.

  5. def buildGraph[N, A, B](ctxs: Seq[Context[N, A, B]]): Graph[N, A, B]

    Build a graph from a list of contexts

  6. def clear[N, A, B](g: GraphRep[N, A, B], v: N, ns: Vector[N], f: (GrContext[N, A, B]) ⇒ GrContext[N, A, B]): GraphRep[N, A, B]

  7. def clearPred[N, A, B](g: GraphRep[N, A, B], v: N, ns: Vector[N]): GraphRep[N, A, B]

  8. def clearSucc[N, A, B](g: GraphRep[N, A, B], v: N, ns: Vector[N]): GraphRep[N, A, B]

  9. implicit def contextOrder[N, A, B](implicit N: Order[N], A: Order[A], B: Order[B]): Order[Context[N, A, B]]

  10. def cycle[N](vs: Seq[N]): Graph[N, Unit, Unit]

    Create a graph that is a cycle of the given nodes

  11. implicit def edgeOrder[N, A](implicit N: Order[N]): Order[Edge[N]]

  12. def empty[N, A, B]: Graph[N, A, B]

    An empty graph

  13. def fromAdj[N, B](adj: Adj[N, B]): Map[N, Set[B]]

    Turn an adjacency list of labeled edges into an intmap of sets of labels

  14. implicit def gdecompOrder[N, A, B](implicit arg0: Order[N], arg1: Order[A], arg2: Order[B]): Order[GDecomp[N, A, B]]

  15. def getLPath[N, A](v: N, t: LRTree[N, A]): Option[LPath[N, A]]

    Find the first path in a labeled search tree that starts with the given node

  16. def getPath[N](v: N, t: RTree[N]): Option[Path[N]]

    Find the first path in a search tree that starts with the given node

  17. implicit def graphMonoid[N, A, B]: Monoid[Graph[N, A, B]]

    The monoid of graph unions

  18. implicit def graphOrder[N, A, B](implicit N: Order[N], A: Order[A], B: Order[B]): Order[Graph[N, A, B]]

  19. implicit def ledgeOrder[N, A](implicit N: Order[N], A: Order[A]): Order[LEdge[N, A]]

  20. def mkGraph[N, A, B](vs: Seq[LNode[N, A]], es: Seq[LEdge[N, B]]): Graph[N, A, B]

    Create a graph from lists of labeled nodes and edges

  21. implicit def nodeOrder[N, A](implicit N: Order[N], A: Order[A]): Order[LNode[N, A]]

  22. def poset[N, A](ns: Seq[(N, A)])(implicit N: PartialOrdering[N]): Graph[N, A, Unit]

    Build a graph from elements of a partially ordered set.

    Build a graph from elements of a partially ordered set. The resulting graph has an edge from vertex x to vertex y precisely when x <= y.

  23. def safeMkGraph[N, A, B](vs: Seq[LNode[N, A]], es: Seq[LEdge[N, B]]): Graph[N, A, B]

    Build a graph from lists of labeled nodes and edges, ignoring edges that reference missing nodes

  24. def star(n: Int): Graph[Int, Unit, Unit]

    Create a directed star graph of degree n

  25. def toAdj[N, B](bs: Map[N, Set[B]]): Adj[N, B]

    Turn an intmap of sets of labels into an adjacency list of labeled edges

  26. package viz

Inherited from AnyRef

Inherited from Any

Graph Construction

Type Aliases

Type Class Instances

Ungrouped