class MuGraphAlgebra[TLabel] extends MuGraph[TLabel]
The MuGraphAlgebra class provide graph algebra operation on MuGraphs.
----------------------------------------------------------------------------
- Alphabetic
- By Inheritance
- MuGraphAlgebra
- MuGraph
- Graph
- Cloneable
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Instance Constructors
- new MuGraphAlgebra(ch: Array[Set[Int]], label: Array[TLabel], elabel: Map[Pair, Set[TLabel]], inverse: Boolean = false, name: String = "g", id: Array[Int] = Array (), schema: Array[String] = Array ())(implicit arg0: ClassTag[TLabel])
- ch
the array of child (adjacency) vertex sets (outgoing edges)
- label
the array of vertex labels: v -> vertex label
- elabel
the map of edge labels: (u, v) -> edge label
- inverse
whether to store inverse adjacency sets (parents)
- name
the name of the multi-digraph
- id
the array of vertex id's
- schema
optional schema: map from label to label type
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 addPar(): Unit
Add the inverse adjacency sets for rapid accesses to parent vertices.
Add the inverse adjacency sets for rapid accesses to parent vertices.
- Definition Classes
- Graph
- def addVertices(g: MuGraph[TLabel], vset: Set[Int], makeMap: Boolean = false): (Array[TLabel], Map[Int, Int])
Create an array vertices from selected vertices from graph 'g', those in 'vset'.
Create an array vertices from selected vertices from graph 'g', those in 'vset'. If 'makeMap', record the mapping between g's vertices and the new vertices.
- g
graph to be used for adding vertex labels
- vset
selected vertices from graph g
- makeMap
whether to make a map from new vertex id's to old vertex id's
- Definition Classes
- MuGraph
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def buildId: Array[Int]
Create an array [1, 2, ..., size] for default values for 'id's.
Create an array [1, 2, ..., size] for default values for 'id's.
- Definition Classes
- MuGraph
- def buildIndex(): Unit
Builds index from (start vertex, edge) -> end vertex.
Builds index from (start vertex, edge) -> end vertex.
- Definition Classes
- MuGraph
- def buildLabelMap(label: Array[TLabel]): Map[TLabel, Set[Int]]
Given an array of labels, return an index from labels to the sets of vertices containing those labels.
Given an array of labels, return an index from labels to the sets of vertices containing those labels.
- label
the array of vertex labels of type
TLabel
- Definition Classes
- Graph
- val ch: Array[Set[Int]]
- Definition Classes
- Graph
- def checkEdges: Boolean
Check whether the end-point vertex id of each edge is within bounds: '0 ..
Check whether the end-point vertex id of each edge is within bounds: '0 .. maxId'.
- Definition Classes
- Graph
- def checkElabels: Boolean
Check whether the edges in the 'elabel' map correspond to edges in the the adjacency list.
Check whether the edges in the 'elabel' map correspond to edges in the the adjacency list.
- Definition Classes
- MuGraph
- def children(u: Int, elab: TLabel): Set[Int]
Return the children of vertex 'u' that are connected via an edge labeled 'elab'.
Return the children of vertex 'u' that are connected via an edge labeled 'elab'.
- u
the source vertex
- elab
the edge label
- Definition Classes
- MuGraph
- def clone(): MuGraph[TLabel]
Clone (make a deep copy) of 'this' multi-digraph.
- val count: HashMap[(TLabel, TLabel, Int), Int]
count of no.
count of no. of occurences of a pair of vertices with a particular edge
- Definition Classes
- MuGraph
- val edgeMap: HashMap[TLabel, Set[Pair]]
index from edges the set of pairs of nodes
index from edges the set of pairs of nodes
- Definition Classes
- MuGraph
- val elabel: Map[Pair, Set[TLabel]]
- Definition Classes
- MuGraph
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def equals(g2_: Any): Boolean
To check if two graphs are equal.
To check if two graphs are equal.
- g2_
the graph to be compared with this graph
- Definition Classes
- MuGraph → AnyRef → Any
- def expand(paths: Rows, elab: TLabel, keep: Boolean = false): Rows
Expand, expands the given paths by adding one forward edge of given edge label to each path.
Expand, expands the given paths by adding one forward edge of given edge label to each path.
- paths
the paths to be expanded
- elab
the label of the edges to be expanded
- keep
whether the given path has to be inluded along with the expanded vertices
- def expandAll(paths: Rows, keep: Boolean = false): Rows
Expand all, expands the given paths by adding one forward edge to each path.
Expand all, expands the given paths by adding one forward edge to each path.
- paths
the paths to be expanded
- keep
whether the given path has to be included along with the expanded vertices
- def expandBack(paths: Rows, elab: TLabel, keep: Boolean = false): Rows
Exapand back, expands(of given edge label) the edges in backward direction, one at a time.
Exapand back, expands(of given edge label) the edges in backward direction, one at a time.
- paths
the paths(set of edges) that are already explored
- elab
the edge label of the edges to be expanded
- keep
whether the given path has to be inluded along with the expanded vertices
- def expandBackAll(paths: Rows, keep: Boolean = false): Rows
Exapand back all, expands the edges of given paths in backward direction, one at a time.
Exapand back all, expands the edges of given paths in backward direction, one at a time.
- paths
the paths(set of edges)
- keep
whether the given path has to be inluded along with the expanded vertices
- def expandBackBySchema(paths: Rows, lab: String, keep: Boolean = false): Rows
Expand back by type, expands the given paths by adding one backward edge (of given type lab) to each path.
Expand back by type, expands the given paths by adding one backward edge (of given type lab) to each path.
- paths
the paths to be expanded
- keep
whether the given path has to be inluded along with the expanded vertices
- def expandBySchema(paths: Rows, lab: String, keep: Boolean = false): Rows
Expand by schema, expands the given paths by adding one forward edge (of given type lab) to each path.
Expand by schema, expands the given paths by adding one forward edge (of given type lab) to each path.
- paths
the paths to be expanded
- keep
whether the given path has to be inluded along with the expanded vertices
- def expandEdges(paths: Rows): Rows_lab
Expand edges, expands the paths and return the name of edges.
Expand edges, expands the paths and return the name of edges.
- paths
the paths to be expanded
- def expandInto(paths: Rows, elab: TLabel): Rows
Expand into, checks if there is an edge from the last node in the given path to the first node in the same path (leading to a triangle).
Expand into, checks if there is an edge from the last node in the given path to the first node in the same path (leading to a triangle).
- paths
the vertices connected by a path
- elab
the edge label to be checked from the end node in the path to the start node
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def getLabels(rows: Rows): Rows_lab
The getLabels returns the labels of the given vertices (indices).
The getLabels returns the labels of the given vertices (indices).
- rows
the indices of vertices in the form of rows
- def getVertices: Rows
Return all the vertices in the graph.
- def getVerticesWithLabel(l: TLabel): Set[Int]
Return the set of vertices in 'this' digraph with label 'l'.
Return the set of vertices in 'this' digraph with label 'l'.
- l
the label to match
- Definition Classes
- Graph
- def hashCode(): Int
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- val id: Array[Int]
- Definition Classes
- MuGraph
- def indexEdges(): Unit
Build and index from edge -> (Vertex pair).
Build and index from edge -> (Vertex pair).
- Definition Classes
- MuGraph
- val indexMap: HashMap[(TLabel, TLabel), Set[Int]]
index from (source node, edge) to the destination node
index from (source node, edge) to the destination node
- Definition Classes
- MuGraph
- def induceEdges(vset: Path, new_index: ReArray[Int], g2: MuGraph[TLabel]): Map[Pair, Set[TLabel]]
Induce edges, of the vertices 'vset' that are conatined in 'this' graph and graph g2.
Induce edges, of the vertices 'vset' that are conatined in 'this' graph and graph g2.
- vset
the vertex set
- new_index
contains the reference to old indexes
- g2
graph g2
- def induceEdges(renumb: Map[Int, Int], g2: MuGraph[TLabel]): Map[Pair, Set[TLabel]]
Induce edges, edges corresponding to 'this' graph and 'g2' graph are induced.
Induce edges, edges corresponding to 'this' graph and 'g2' graph are induced.
- renumb
the map from new index -> old index
- g2
the graph g2
- def induceEdges(vset: Path, new_index: ReArray[Int]): Map[Pair, Set[TLabel]]
Induce edges, the map of edges with the vertices only from vset
Induce edges, the map of edges with the vertices only from vset
- vset
the set of vertices, to be considered for selecting the edges
- new_index
the old index of the vertices to be used for accessing edges of graph
- def intersect(g2: MuGraph[TLabel]): MuGraph[TLabel]
Intersect, performs the interscetion of two graphs including vertices and edges.
Intersect, performs the interscetion of two graphs including vertices and edges.
- g2
the graph that has to be intersect with the current graph
- var inverse: Boolean
- Definition Classes
- Graph
- def isConnected: Boolean
Determine whether 'this' digraph is (weakly) connected.
Determine whether 'this' digraph is (weakly) connected.
- Definition Classes
- Graph
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- val label: Array[TLabel]
- Definition Classes
- Graph
- val labelMap: Map[TLabel, Set[Int]]
The map from label to the set of vertices with the label
The map from label to the set of vertices with the label
- Definition Classes
- Graph
- def makeUndirected(): MuGraph[TLabel]
Make this multi-directed graph work like an undirected graph by making sure that for every edge 'u -> v', there is a 'v -> u' edge and that they have same edge label.
- def minus(g2: MuGraph[TLabel]): MuGraph[TLabel]
Perform the minus operation of two graphs.
Perform the minus operation of two graphs.
- g2
the subgraph to be excluded from this graph
- def nEdges: Int
Return the number of edges in 'this' digraph.
Return the number of edges in 'this' digraph.
- Definition Classes
- Graph
- def nSelfLoops: Int
Determine the number of vertices in the digraph that have outgoing edges to themselves.
Determine the number of vertices in the digraph that have outgoing edges to themselves.
- Definition Classes
- Graph
- val name: String
- Definition Classes
- Graph
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- val pa: Array[Set[Int]]
The optional array of vertex inverse (parent) adjacency sets (incoming edges)
The optional array of vertex inverse (parent) adjacency sets (incoming edges)
- Definition Classes
- Graph
- def parents(v: Int, elab: TLabel): Set[Int]
Return the parents of vertex 'v' that are connected via an edge labeled 'elab'.
Return the parents of vertex 'v' that are connected via an edge labeled 'elab'. Requires the parents 'pa' to be added (@see
Graph).- v
the destination vertex
- elab
the edge label
- Definition Classes
- MuGraph
- def printG(clip: Boolean = true): Unit
Print 'this' multi-digraph in a deep sense with all the information.
- def renumber(x: Pair, renumb: Map[Int, Int]): Pair
Renumber, check if the vertices are renumbered.
Renumber, check if the vertices are renumbered.
- x
pair of vertices
- renumb
a map containing the map from old to new vertex
- def same(i: Int, g1: MuGraph[TLabel], g2: MuGraph[TLabel]): Boolean
Same, checks if a vertex is same in two graphs.
Same, checks if a vertex is same in two graphs.
- i
index of the vertex
- g1
first graph
- g2
second graph
- def same(g: Graph[TLabel]): Boolean
Determine whether 'this' digraph and digraph 'g' have the same vertices and edges.
Determine whether 'this' digraph and digraph 'g' have the same vertices and edges. Note, this is more strict than graph isomorphism which allows vertices to be renumbered.
- g
the other digraph
- Definition Classes
- Graph
- val schema: Array[String]
- Definition Classes
- MuGraph
- def selectByELabel(θ: (TLabel, TLabel) => Boolean, c: TLabel, schema: Array[String])(vs: Set[Int]): Array[(Pair, Set[TLabel])]
Select by edge label the edges in the graph having both the vertices 'vs' and satifying the theta predicate 'exists elabel(e) θ c'.
Select by edge label the edges in the graph having both the vertices 'vs' and satifying the theta predicate 'exists elabel(e) θ c'.
- θ
comparison/theta operator
- c
the vertex label sought
- vs
the set of vertices to be considered for the input graph
- def selectByEdgeGraph(θ: (TLabel, TLabel) => Boolean, c: TLabel): MuGraph[TLabel]
Select by edge, the Graph with the edges satisfying the theta predicate
Select by edge, the Graph with the edges satisfying the theta predicate
- θ
comparison operator
- c
label of the edge
- def selectBySchema(θ: (String, String) => Boolean, c: String)(vs: Set[Int] = null): Rows
Select by schema type the vertices in the graph satifying the theta predicate 'schema(v) θ c'.
Select by schema type the vertices in the graph satifying the theta predicate 'schema(v) θ c'.
- θ
comparison/theta operator
- c
the vertex label sought
- vs
the set of vertices to be considered for the input graph
- def selectByVLabel(θ: (TLabel, TLabel) => Boolean, c: TLabel)(vs: Set[Int] = null): Rows
Select by vertex label the vertices in the graph satifying the theta predicate 'label(v) θ c'.
Select by vertex label the vertices in the graph satifying the theta predicate 'label(v) θ c'.
- θ
comparison/theta operator
- c
the vertex label sought
- vs
the set of vertices to be considered for the input graph
- def selectByVertexGraph(θ: (TLabel, TLabel) => Boolean, c: TLabel): MuGraph[TLabel]
Select by vertex, the graph with the vertices satisfying the theta predicate, and the edges connecting the selected vertices
Select by vertex, the graph with the vertices satisfying the theta predicate, and the edges connecting the selected vertices
- θ
comparison/theta operator
- c
label of the vertex
- def size: Int
Return the size of graph in terms of the number of vertices.
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def toGraphIm(name2: String = name): graphalytics.Graph
Return the equivalent immutable Graph.
Return the equivalent immutable Graph. Assumes the default
TLabelof typeString. For other types (e.g.,Doubleuse '_.toDouble' rather than '.toString' in the last line of this method.- name2
the name to give the new immutable Graph
- Definition Classes
- Graph
- See also
scalation.graphalytics.Graph
- def toLine(i: Int, clip: Boolean = true): String
Convert the 'i'th row/line of 'this' multi-digraph to a string.
- def toString(): String
Convert 'this' multi-digraph to a string in a shallow sense.
- def union(x: Rows_lab, y: Rows_lab): Rows_lab
Union, the result rows are combined.
Union, the result rows are combined.
- x
rows produced as result from the first operation
- y
rows produced as result from the second operation
- def union(g2: MuGraph[TLabel]): MuGraph[TLabel]
Union, performs the union of two graphs including both vertices and edges
Union, performs the union of two graphs including both vertices and edges
- g2
the graph that has to be unioned with 'this' graph
- def union(g2: Graph[TLabel]): Graph[TLabel]
Take the union 'this' digraph and 'g2'.
- def vertexSet: Set[Int]
Return the indices of all vertices in the graph.
- val vid: Array[Int]
- Definition Classes
- Graph
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
Deprecated Value Members
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated
- Deprecated