quiver

Type Members

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

Labeled links to or from a node
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.
case class Context[N, A, B](inEdges: Adj[N, B], vertex: N, label: A, outEdges: Adj[N, B]) extends Product with Serializable

The view of a graph focused on the context surrounding a particular node.
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 a detached context focused on one node and the rest of the graph.
case class Edge[N](from: N, to: N) extends Product with Serializable

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

The same as Decomp, only more sure of itself
case class GrContext[N, A, B](inEdges: Map[N, Set[B]], label: A, outEdges: Map[N, Set[B]]) extends Product with Serializable

The label, predecessors, and successors of a given node
case class Graph[N, A, B](rep: GraphRep[N, A, B]) extends Product with Serializable

An implementation of an inductive graph using Map.
An implementation of an inductive graph using Map. Nodes are labeled with A, and edges are labeled with B.
type GraphRep[N, A, B] = Map[N, GrContext[N, A, B]]

The internal representation of a graph
case class LEdge[N, A](from: N, to: N, label: A) extends Product with Serializable

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

Labeled Node
type UEdge[N] = LEdge[N, Unit]

Quasi-unlabaled edge
type UNode[N] = LNode[N, Unit]

Quasi-unlabeled node

Value Members

def addPred[N, A, B](g: GraphRep[N, A, B], v: N, lss: Vector[(B, N)]): GraphRep[N, A, B]
def addSucc[N, A, B](g: GraphRep[N, A, B], v: N, lps: Vector[(B, N)]): GraphRep[N, A, B]
def buildGraph[N, A, B](ctxs: Seq[Context[N, A, B]]): Graph[N, A, B]

Build a graph from a list of contexts
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]
def clearPred[N, A, B](g: GraphRep[N, A, B], v: N, ns: Vector[N]): GraphRep[N, A, B]
def clearSucc[N, A, B](g: GraphRep[N, A, B], v: N, ns: Vector[N]): GraphRep[N, A, B]
implicit def edgeOrder[N, A](implicit N: Order[N]): Order[Edge[N]]
def empty[N, A, B]: Graph[N, A, B]

An empty graph
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
implicit def graphMonoid[N, A, B]: Monoid[Graph[N, A, B]]
implicit def graphOrder[N, A, B](implicit N: Order[N], A: Order[A], B: Order[B]): Order[Graph[N, A, B]]
implicit def ledgeOrder[N, A](implicit N: Order[N], A: Order[A]): Order[LEdge[N, A]]
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
implicit def nodeOrder[N, A](implicit N: Order[N], A: Order[A]): Order[LNode[N, A]]
def safeMkGraph[N, A, B](vs: Seq[LNode[N, A]], es: Seq[LEdge[N, B]]): Graph[N, A, B]
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
package viz

package quiver

Type Members

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

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

case class Context[N, A, B](inEdges: Adj[N, B], vertex: N, label: A, outEdges: Adj[N, B]) extends Product with Serializable

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

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

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

case class GrContext[N, A, B](inEdges: Map[N, Set[B]], label: A, outEdges: Map[N, Set[B]]) extends Product with Serializable

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

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

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

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

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

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

Value Members

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

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

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

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]

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

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

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

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

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

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

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

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

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

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

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

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

package viz

Inherited from AnyRef

Inherited from Any

Ungrouped