RootGraph 
method  time complexity 
createGraphPerspective(Node[], Edge[]) 
A GraphPerspective is created in O(N + E) time, where N is the
length of the Node input array and E is the length of the Edge
input array. 
createGraphPerspective(int[], int[]) 
A GraphPerspective is created in O(N + E) time, where N is the
length of the first input int array and E is the length of the
second input int array. 
ensureCapacity(int, int) 
This method returns in constant time. 
getNodeCount() 
The total node count is calculated in constant time. 
getEdgeCount() 
The total edge count is calculated in constant time. 
nodesIterator() 
An Iterator is returned in constant time. Each successive element
in the iteration is returned in constant time. 
nodesList() 
A List of Node objects is returned in O(N) time, where N is the
number of nodes in this RootGraph. 
getNodeIndicesArray() 
An array of node indices is returned in O(N) time, where N is the
number of nodes in this RootGraph. 
edgesIterator() 
An iterator is returned in constant time. Each successive element
in the iteration is returned in constant time. 
edgesList() 
A List of Edge objects is returned in O(E) time, where E is the
number of edges in this RootGraph. 
getEdgeIndicesArray() 
An array of edge indices is returned in O(E) time, where E is the
number of edges in this RootGraph. 
removeNode(Node) 
Essentially, the operation of removing a node takes O(E) time where
E is the number of edges touching the node being removed. However,
this is no longer an absolute truth once many GraphPerspective
objects are created from this RootGraph, or many metanode
relationships are created which involve the node being removed. 
removeNode(int) 
Essentially, the operation of removing a node takes O(E) time where
E is the number of edges touching the node being removed. However,
this is no longer an absolute truth once many GraphPerspective
objects are created from this RootGraph, or many metanode
relationships are created which involve the node being removed. 
removeNodes(List) 
Essentially, the operation of removing a node takes O(E) time where
E is the number of edges touching the node being removed. However,
this is no longer an absolute truth once many GraphPerspective
objects are created from this RootGraph, or many metanode
relationships are created which involve the node being removed.
This method removes each node in succession. 
removeNodes(int[]) 
Essentially, the operation of removing a node takes O(E) time where
E is the number of edges touching the node being removed. However,
this is no longer an absolute truth once many GraphPerspective
objects are created from this RootGraph, or many metanode
relationships are created which involve the node being removed.
This method removes each node in succession. 
createNode() 
A node is created in constant time. 
createNode(Node[], Edge[]) 
This metanode operation takes O(N + E) time, where N is the
length of the input Node array and E is the length of the input
Edge array. 
createNode(GraphPerspective) 
This metanode operation takes O(N + E) time, where N is the
number of nodes in specified GraphPerspective and E is the
number of edges in specified GraphPerspective. 
createNode(int[], int[]) 
This metanode operation takes O(N + E) time, where N is the
length of the first input int array and E is the length of the
second input int array. 
createNodes(int) 
A node is created in constant time. This method creates the
specified number of nodes in succession. 
removeEdge(Edge) 
Essentially, the operation of removing an edge takes constant time.
However, this is no longer an absolute truth once many
GraphPerspective objects are created from this RootGraph, or many
metanode relationships are created which involve the edge being
removed. 
removeEdge(int) 
Essentially, the operation of removing an edge takes constant time.
However, this is no longer an absolute truth once many
GraphPerspective objects are created from this RootGraph, or many
metanode relationships are created which involve the edge being
removed. 
removeEdges(List) 
Essentially, the operation of removing an edge takes constant time.
However, this is no longer an absolute truth once many
GraphPerspective objects are created from this RootGraph, or many
metanode relationships are created which involve the edge being
removed. This removes each edge successively. 
removeEdges(int[]) 
Essentially, the operation of removing an edge takes constant time.
However, this is no longer an absolute truth once many
GraphPerspective objects are created from this RootGraph, or many
metanode relationships are created which involve the edge being
removed. This removes each edge successively. 
createEdge(Node, Node) 
The operation of creating an edge is performed in constant time. 
createEdge(Node, Node, boolean) 
The operation of creating an edge is performed in constant time. 
createEdge(int, int) 
The operation of creating an edge is performed in constant time. 
createEdge(int, int, boolean) 
The operation of creating an edge is performed in constant time. 
createEdges(int[], int[], boolean) 
The operation of creating an edge is performed in constant time.
This creates each edge in succession. 
containsNode(Node) 
Determining whether or not a node is in a RootGraph takes
constant time. 
containsEdge(Edge) 
Determining whether or not an edge is in a RootGraph takes
constant time. 
neighborsList(Node) 
Node neighbors are calculated on O(E) time, where E is the number of
edges touching the node whose neighbors we're calculating. 
isNeighbor(Node, Node) 
The operation of determining whether or not two nodes are
neighbors has time complexity O(min(E, F)), where E is the number of
edges touching one node and F is the number of edges touching the
other node (this is actually oversimplified and more pessimistic
than it could be). 
isNeighbor(int, int) 
The operation of determining whether or not two nodes are
neighbors has time complexity O(min(E, F)), where E is the number of
edges touching one node and F is the number of edges touching the
other node (this is actually oversimplified and more pessimistic
than it could be). 
edgeExists(Node, Node) 
The operation of determining whether or not an edge exists starting
at one [specified] node and ending at another [specified] node
has time complexity O(min(E, F)), where E is the number of
edges touching one node and F is the number of edges touching the
other node (this is actually oversimplified and more pessimistic
than it could be). 
edgeExists(int, int) 
The operation of determining whether or not an edge exists starting
at one [specified] node and ending at another [specified] node
has time complexity O(min(E, F)), where E is the number of
edges touching one node and F is the number of edges touching the
other node (this is actually oversimplified and more pessimistic
than it could be). 
getEdgeCount(Node, Node, boolean) 
The operation of determining the number of existig edges starting at
one [specified] node and ending at another [specified] node has
time complexity O(min(E, F)), where E is the number of edges touching
one node and F is the number of edges touching the other node. 
getEdgeCount(int, int, boolean) 
The operation of determining the number of existing edges starting at
one [specified] node and ending at another [specified] node has
time complexity O(min(E, F)), where E is the number of edges touching
one node and F is the number of edges touching the other node. 
getAdjacentEdgeIndicesArray(int, boolean, boolean, boolean) 
The operation of getting edges adjacent to a node, fitting
defined characteristics (specified by three boolean values) has
time complexity O(E), where E is the total number of edges touching
the node in question. 
getConnectingEdgeIndicesArray(int[]) 
Computing a "connecting web" of edges from a list of input nodes
has time complexity O(E), where E is the number of edges touching
at least one node in the input set of nodes. 
getConnectingNodeIndicesArray(int[]) 
This method has time complexity O(E), where E is the length
of the input array. 
getEdgeIndicesArray(int, int, boolean, boolean) 
The operation of finding all edges [meeting certain criteria,
specified by two boolean input parameters] starting at one [specified]
node and ending at another [specified] node has time complexity
O(min(E, F)), where E is the total number of edges touching the
start node and F is the total number of edges touching the end
node. 
edgesList(Node, Node) 
The operation of finding all edges starting at one [specified]
node and ending at another [specified] node has time complexity
O(min(E, F)), where E is the total number of edges touching the
start node and F is the total number of edges touching the end
node. 
edgesList(int, int, boolean) 
The operation of finding all edges starting at one [specified]
node and ending at another [specified] node has time complexity
O(min(E, F)), where E is the total number of edges touching the
start node and F is the total number of edges touching the end
node. 
getEdgeIndicesArray(int, int, boolean) 
The operation of finding all edges starting at one [specified]
node and ending at another [specified] node has time complexity
O(min(E, F)), where E is the total number of edges touching the
start node and F is the total number of edges touching the end
node. 
getInDegree(int) 
All degreecomputing methods are executed in constant time. 
getInDegree(Node, boolean) 
All degreecomputing methods are executed in constant time. 
getInDegree(int, boolean) 
All degreecomputing methods are executed in constant time. 
getOutDegree(Node) 
All degreecomputing methods are executed in constant time. 
getOutDegree(int) 
All degreecomputing methods are executed in constant time. 
getOutDegree(Node, boolean) 
All degreecomputing methods are executed in constant time. 
getOutDegree(int, boolean) 
All degreecomputing methods are executed in constant time. 
getDegree(Node) 
All degreecomputing methods are executed in constant time. 
getDegree(int) 
All degreecomputing methods are executed in constant time. 
getIndex(Node) 
The index of a node is computed in constant time. 
getNode(int) 
A node is retrieved in constant time. 
getIndex(Edge) 
The index of an edge is computed in constant time. 
getEdge(int) 
An edge is retrieved in constant time. 
getEdgeSourceIndex(int) 
The source node of an edge is determined in constant time. 
getEdgeTargetIndex(int) 
The target node of an edge is determined in constant time. 
isEdgeDirected(int) 
The directedness of an edge is determined in constant time. 
addMetaChild(Node, Node) 
Adding a node>node metarelationship has time complexity
O(min(P, C)), where P is the number of preexisting children the
soontobe parent has, and C is the number of preexisting parents
the soontobe child has. 
addNodeMetaChild(int, int) 
Adding a node>node metarelationship has time complexity
O(min(P, C)), where P is the number of preexisting children the
soontobe parent has, and C is the number of preexisting parents
the soontobe child has. 
removeNodeMetaChild(int, int) 
Grrr. This is complicated. In the simplest case (and in the
case that will occur frequently), this is much like removing
a node from a graph  the time complexity is O(E), where E is the
number of edges touching the child node. 
isMetaParent(Node, Node) 

isNodeMetaParent(int, int) 

metaParentsList(Node) 

nodeMetaParentsList(int) 

getNodeMetaParentIndicesArray(int) 

isMetaChild(Node, Node) 

isNodeMetaChild(int, int) 
The operation of determining whether or not a given node is the
metaparent of another given node has time complexity O(min(P, C)),
where P is the number of children (both nodes and edges) the potential
parent has, and C is the number of parents the potential child
has. 
isNodeMetaChild(int, int, boolean) 
The recursive version of this method does a depthfirst search of
the metagraph structure starting at the specified parent node;
therefore, the time complexity of this recursive operation is
O(M), where M is the size of set (including both nodes and edges)
"reachable" by following metapaths from parent to child, starting
at specified parent node. 
nodeMetaChildrenList(Node) 
The operation of getting all node children of a given parent node
has time complexity O(C), where C is the number of children of the
given parent node, including both nodes and edges. 
nodeMetaChildrenList(int) 
The operation of getting all node children of a given parent node
has time complexity O(C), where C is the number of children of the
given parent node, including both nodes and edges. 
getNodeMetaChildIndicesArray(int) 
The operation of getting all node children of a given parent node
has time complexity O(C), where C is the number of children of the
given parent node, including both nodes and edges. 
getNodeMetaChildIndicesArray(int, boolean) 

getChildlessMetaDescendants(int) 

addMetaChild(Node, Edge) 

addEdgeMetaChild(int, int) 

removeEdgeMetaChild(int, int) 

isMetaParent(Edge, Node) 

isEdgeMetaParent(int, int) 

metaParentsList(Edge) 

edgeMetaParentsList(int) 

getEdgeMetaParentIndicesArray(int) 

isMetaChild(Node, Edge) 

isEdgeMetaChild(int, int) 

edgeMetaChildrenList(Node) 

edgeMetaChildrenList(int) 

getEdgeMetaChildIndicesArray(int) 
