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.
- Alphabetic
- By Inheritance
- GDecomp
- Serializable
- Serializable
- Product
- Equals
- AnyRef
- Any
- by any2stringadd
- by StringFormat
- by Ensuring
- by ArrowAssoc
- Hide All
- Show All
- Public
- All
Value Members
-
final
def
!=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
-
final
def
##(): Int
- Definition Classes
- AnyRef → Any
- def +(other: String): String
- def ->[B](y: B): (GDecomp[N, A, B], B)
-
final
def
==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def addPred(node: LNode[N, A], edge: B): GDecomp[N, A, B]
- def addSucc(node: LNode[N, A], edge: B): GDecomp[N, A, B]
-
final
def
asInstanceOf[T0]: T0
- Definition Classes
- Any
-
def
back(b: B): Vector[GDecomp[N, A, B]]
Decompose the graph on predecessors of the focused node, following incoming edges labeled with
b
.Decompose the graph on predecessors of the focused node, following incoming edges labeled with
b
. O(n) in the degree of the focused node. -
def
clone(): AnyRef
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( ... )
- val ctx: Context[N, A, B]
- def ensuring(cond: (GDecomp[N, A, B]) ⇒ Boolean, msg: ⇒ Any): GDecomp[N, A, B]
- def ensuring(cond: (GDecomp[N, A, B]) ⇒ Boolean): GDecomp[N, A, B]
- def ensuring(cond: Boolean, msg: ⇒ Any): GDecomp[N, A, B]
- def ensuring(cond: Boolean): GDecomp[N, A, B]
-
final
def
eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
def
extend[C](f: (GDecomp[N, A, B]) ⇒ C): GDecomp[N, C, B]
Recursively decompose the graph, passing each decomposition to the given function, storing the results as labels.
Recursively decompose the graph, passing each decomposition to the given function, storing the results as labels. The resulting decomposition has the exact same structure as this one, just redecorated with new labels. This differs from
redecorate
in that calls tof
see successively smaller subgraphs as each decomposition removes a node. -
def
finalize(): Unit
- Attributes
- protected[java.lang]
- Definition Classes
- AnyRef
- Annotations
- @throws( classOf[java.lang.Throwable] )
- def formatted(fmtstr: String): String
-
def
forward(b: B): Vector[GDecomp[N, A, B]]
Decompose the graph on successors of the focused node, following outgoing edges labeled with
b
.Decompose the graph on successors of the focused node, following outgoing edges labeled with
b
. O(n) in the degree of the focused node. -
final
def
getClass(): Class[_]
- Definition Classes
- AnyRef → Any
-
def
ins: Vector[GDecomp[N, A, B]]
Decompose the graph on predecessors of the focused node.
Decompose the graph on predecessors of the focused node. O(n) in the outdegree of the focused node.
-
final
def
isInstanceOf[T0]: Boolean
- Definition Classes
- Any
-
def
label: A
Get the label of the node under focus
-
def
map[C](f: (A) ⇒ C): GDecomp[N, C, B]
Map over the labels in this decomposition
-
def
move(f: (Context[N, A, B]) ⇒ Vector[N]): Vector[GDecomp[N, A, B]]
Decompose the graph on the nodes returned by
f
.Decompose the graph on the nodes returned by
f
. O(n) in the degree of the focused node. -
final
def
ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
-
final
def
notify(): Unit
- Definition Classes
- AnyRef
-
final
def
notifyAll(): Unit
- Definition Classes
- AnyRef
-
def
outs: Vector[GDecomp[N, A, B]]
Decompose the graph on successors of the focused node.
Decompose the graph on successors of the focused node. O(n) in the indegree of the focused node.
-
def
redecorate[C](f: (GDecomp[N, A, B]) ⇒ C): GDecomp[N, C, B]
Decompose the graph on each node in turn, and apply the given function on each such "rotation", storing the results as labels.
Decompose the graph on each node in turn, and apply the given function on each such "rotation", storing the results as labels. The resulting decomposition has the exact same structure as this one, just redecorated with new labels. This differs from
extend
in that each call tof
sees the entire graph from different perspectives. - val rest: Graph[N, A, B]
-
final
def
synchronized[T0](arg0: ⇒ T0): T0
- Definition Classes
- AnyRef
- def toDecomp: Decomp[N, A, B]
- def toGraph: Graph[N, A, B]
-
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( ... )
- def →[B](y: B): (GDecomp[N, A, B], B)