def to_undirected(self):
"""Return an undirected representation of the digraph.
Returns
-------
G : Graph
An undirected graph with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
Notes
-----
If edges in both directions (u,v) and (v,u) exist in the
graph, attributes for the new undirected edge will be a combination of
the attributes of the directed edges. The edge data is updated
in the (arbitrary) order that the edges are encountered. For
more customized control of the edge attributes use add_edge().
This is similar to Graph(self) which returns a shallow copy.
self.to_undirected() returns a deepcopy of edge, node and
graph attributes.
"""
H=Graph()
H.name=self.name
H.add_nodes_from(self)
H.add_edges_from( (u,v,deepcopy(d))
for u,nbrs in self.adjacency_iter()
for v,d in nbrs.iteritems() )
H.graph=deepcopy(self.graph)
H.node=deepcopy(self.node)
return H
def to_undirected(self):
"""Return an undirected representation of the digraph.
Returns
-------
G : Graph
An undirected graph with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
Notes
-----
If edges in both directions (u,v) and (v,u) exist in the
graph, attributes for the new undirected edge will be a combination of
the attributes of the directed edges. The edge data is updated
in the (arbitrary) order that the edges are encountered. For
more customized control of the edge attributes use add_edge().
This is similar to Graph(self) which returns a shallow copy.
self.to_undirected() returns a deepcopy of edge, node and
graph attributes.
"""
H = Graph()
H.name = self.name
H.add_nodes_from(self)
H.add_edges_from((u, v, deepcopy(d))
for u, nbrs in self.adjacency_iter()
for v, d in nbrs.iteritems())
H.graph = deepcopy(self.graph)
H.node = deepcopy(self.node)
return H
def to_undirected(self, reciprocal=False):
"""Return an undirected representation of the digraph.
Parameters
----------
reciprocal : bool (optional)
If True only keep edges that appear in both directions
in the original digraph.
Returns
-------
G : Graph
An undirected graph with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
Notes
-----
If edges in both directions (u,v) and (v,u) exist in the
graph, attributes for the new undirected edge will be a combination of
the attributes of the directed edges. The edge data is updated
in the (arbitrary) order that the edges are encountered. For
more customized control of the edge attributes use add_edge().
This returns a "deepcopy" of the edge, node, and
graph attributes which attempts to completely copy
all of the data and references.
This is in contrast to the similar G=DiGraph(D) which returns a
shallow copy of the data.
See the Python copy module for more information on shallow
and deep copies, http://docs.python.org/library/copy.html.
Warning
-------
If you have subclassed DiGraph to use dict-like objects in the
data structure, those changes do not transfer to the Graph
created by this method.
"""
H=Graph()
H.name=self.name
H.add_nodes_from(self)
if reciprocal is True:
H.add_edges_from( (u,v,deepcopy(d))
for u,nbrs in self.adjacency_iter()
for v,d in nbrs.items()
if v in self.pred[u])
else:
H.add_edges_from( (u,v,deepcopy(d))
for u,nbrs in self.adjacency_iter()
for v,d in nbrs.items() )
H.graph=deepcopy(self.graph)
H.node=deepcopy(self.node)
return H
def to_undirected(self, reciprocal=False):
"""Return an undirected representation of the digraph.
Parameters
----------
reciprocal : bool (optional)
If True only keep edges that appear in both directions
in the original digraph.
Returns
-------
G : Graph
An undirected graph with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
Notes
-----
If edges in both directions (u,v) and (v,u) exist in the
graph, attributes for the new undirected edge will be a combination of
the attributes of the directed edges. The edge data is updated
in the (arbitrary) order that the edges are encountered. For
more customized control of the edge attributes use add_edge().
This returns a "deepcopy" of the edge, node, and
graph attributes which attempts to completely copy
all of the data and references.
This is in contrast to the similar G=DiGraph(D) which returns a
shallow copy of the data.
See the Python copy module for more information on shallow
and deep copies, http://docs.python.org/library/copy.html.
Warning
-------
If you have subclassed DiGraph to use dict-like objects in the
data structure, those changes do not transfer to the Graph
created by this method.
"""
H = Graph()
H.name = self.name
H.add_nodes_from(self)
if reciprocal is True:
H.add_edges_from((u, v, deepcopy(d))
for u, nbrs in self.adjacency_iter()
for v, d in nbrs.items() if v in self.pred[u])
else:
H.add_edges_from((u, v, deepcopy(d))
for u, nbrs in self.adjacency_iter()
for v, d in nbrs.items())
H.graph = deepcopy(self.graph)
H.node = deepcopy(self.node)
return H
def add_edges():
'''Including an arbitrary attribute with newly added edges will add that attribute to all of the new edges'''
g = Graph([(1, 5), (5, 5)])
g.add_edges_from([[4, 6], (7, 8)], win='yes')
print(g.nodes()) # [1, 5, 4, 6, 7, 8]
print(g.edges()) # [(1, 5), (5, 5), (4, 6), (7, 8)]
print(
g.edge
) # {1: {5: {}}, 5: {1: {}, 5: {}}, 4: {6: {'win': 'yes'}}, 6: {4: {'win': 'yes'}}, 7: {8: {'win': 'yes'}}, 8: {7: {'win': 'yes'}}}
def to_undirected(self):
H = Graph()
H.name = self.name
H.add_nodes_from(self)
H.add_edges_from((u, v, deepcopy(d)) for u, nbrs in self.adjacency_iter() for v, d in nbrs.iteritems())
H.graph = deepcopy(self.graph)
H.node = deepcopy(self.node)
return H
def to_directed(self, as_view=False):
if as_view is True:
return nx.graphviews.DiGraphView(self)
# deepcopy when not a view
from VascGraph.GeomGraph import DiGraph
G = DiGraph()
G.graph.update(deepcopy(self.graph))
G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
G.add_edges_from((u, v, deepcopy(data))
for u, nbrs in self._adj.items()
for v, data in nbrs.items())
return G
def to_undirected(self):
"""Return an undirected representation of the digraph.
A new graph is returned with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
"""
H=Graph()
H.name=self.name
H.add_nodes_from(self)
H.add_edges_from([(v,u,d) for (u,v,d) in self.edges_iter(data=True)])
return H
def to_undirected(self):
"""Return an undirected representation of the digraph.
A new graph is returned with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
"""
H = Graph()
H.name = self.name
H.add_nodes_from(self)
H.add_edges_from([(v, u, d)
for (u, v, d) in self.edges_iter(data=True)])
return H
def create_graph_from_edges():
'''
- Don't use this strategy alone to copy a graph
- None of the arbitrary attributes from nodes, edges, or the graph are copied
- When a new graph is created from the edges of an existing graph, the nodes that form each edge are also created
- Thus, creating a copy from edges is almost a true copy
- It is NOT a true copy because any nodes without edges are not copied!
'''
g = Graph([(1, 5), (5, 5)])
g.add_node(6)
g.edge[1][5]['foo'] = 'bar'
print(g.edge[1][5]) # {'foo': 'bar'}
print(g.nodes()) # [1, 5, 6]
h = Graph()
# Yes, this is the required syntax to do this
h.add_edges_from(g.edges())
print(h.edge[1][5]) # {}
print(h.nodes()) # [1, 5]
print(h.edges()) # [(1, 5), (5, 5)]
def to_undirected(self):
"""Return an undirected representation of the digraph.
Returns
-------
G : Graph
An undirected graph with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
Notes
-----
If edges in both directions (u,v) and (v,u) exist in the
graph, attributes for the new undirected edge will be a combination of
the attributes of the directed edges. The edge data is updated
in the (arbitrary) order that the edges are encountered. For
more customized control of the edge attributes use add_edge().
This returns a "deepcopy" of the edge, node, and
graph attributes which attempts to completely copy
all of the data and references.
This is in contrast to the similar G=DiGraph(D) which returns a
shallow copy of the data.
See the Python copy module for more information on shallow
and deep copies, http://docs.python.org/library/copy.html.
"""
H=Graph()
H.name=self.name
H.add_nodes_from(self)
H.add_edges_from( (u,v,deepcopy(d))
for u,nbrs in self.adjacency_iter()
for v,d in nbrs.iteritems() )
H.graph=deepcopy(self.graph)
H.node=deepcopy(self.node)
return H
def to_undirected(self):
"""Return an undirected representation of the digraph.
Returns
-------
G : Graph
An undirected graph with the same name and nodes and
with edge (u,v,data) if either (u,v,data) or (v,u,data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
Notes
-----
If edges in both directions (u,v) and (v,u) exist in the
graph, attributes for the new undirected edge will be a combination of
the attributes of the directed edges. The edge data is updated
in the (arbitrary) order that the edges are encountered. For
more customized control of the edge attributes use add_edge().
This returns a "deepcopy" of the edge, node, and
graph attributes which attempts to completely copy
all of the data and references.
This is in contrast to the similar G=DiGraph(D) which returns a
shallow copy of the data.
See the Python copy module for more information on shallow
and deep copies, http://docs.python.org/library/copy.html.
"""
H = Graph()
H.name = self.name
H.add_nodes_from(self)
H.add_edges_from((u, v, deepcopy(d))
for u, nbrs in self.adjacency_iter()
for v, d in nbrs.items())
H.graph = deepcopy(self.graph)
H.node = deepcopy(self.node)
return H
def add_snapshot(self, ebunch=None, graph=None, start=None, end=None, time=None):
"""Add a snapshot with a bunch of edge values.
Parameters
----------
ebunch : container of edges, optional (default= None)
Each edge in the ebunch list will be included to all added graphs.
graph : networkx graph object, optional (default= None)
networkx graph to be inserted into snapshot graph.
start: start timestamp, inclusive
end: end timestamp, exclusive
time: timestamp for impulses, cannot be used together with (start, end)
Returns
-------
None
Examples
--------
>>> G = dnx.SnapshotGraph()
>>> G.add_snapshot([(1, 4), (1, 3)], start=0, end=3)
"""
if not graph:
g = Graph()
g.add_edges_from(ebunch)
else:
g = graph
if time is not None and (start or end):
raise ValueError('Time and (start or end) cannot both be specified.')
elif time is not None:
self.insert(g, time=time)
elif start is None and end is None:
raise ValueError('Either time or both start and end must be specified.')
else:
self.insert(g, start=start, end=end)
def add_snapshot(self, ebunch=None, graph=None, num_in_seq=None):
"""Add a snapshot with a bunch of edge values.
Parameters
----------
ebunch : container of edges, optional (default= None)
Each edge in the ebunch list will be included to all added graphs.
graph : networkx graph object, optional (default= None)
networkx graph to be inserted into snapshot graph.
num_in_seq : integer, optional (default= None)
Time slot to begin insertion at.
Returns
-------
None
Examples
--------
>>> G = dnx.SnapshotGraph()
>>> G.add_snapshot([(1, 4), (1, 3)])
"""
if not graph:
g = Graph()
g.add_edges_from(ebunch)
else:
g = graph
if (not num_in_seq) or (num_in_seq == len(self.snapshots) + 1):
self.snapshots.append(g)
elif num_in_seq > len(self.snapshots):
while num_in_seq > len(self.snapshots):
self.snapshots.append(g)
else:
self.insert(g, snap_len=1, num_in_seq=num_in_seq)
def to_undirected(self, reciprocal=False, as_view=False):
"""Returns an undirected representation of the digraph.
Parameters
----------
reciprocal : bool (optional)
If True only keep edges that appear in both directions
in the original digraph.
as_view : bool (optional, default=False)
If True return an undirected view of the original directed graph.
Returns
-------
G : Graph
An undirected graph with the same name and nodes and
with edge (u, v, data) if either (u, v, data) or (v, u, data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
See Also
--------
Graph, copy, add_edge, add_edges_from
Notes
-----
If edges in both directions (u, v) and (v, u) exist in the
graph, attributes for the new undirected edge will be a combination of
the attributes of the directed edges. The edge data is updated
in the (arbitrary) order that the edges are encountered. For
more customized control of the edge attributes use add_edge().
This returns a "deepcopy" of the edge, node, and
graph attributes which attempts to completely copy
all of the data and references.
This is in contrast to the similar G=DiGraph(D) which returns a
shallow copy of the data.
See the Python copy module for more information on shallow
and deep copies, https://docs.python.org/2/library/copy.html.
Warning: If you have subclassed DiGraph to use dict-like objects
in the data structure, those changes do not transfer to the
Graph created by this method.
Examples
--------
>>> G = nx.path_graph(2) # or MultiGraph, etc
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]
>>> G2 = H.to_undirected()
>>> list(G2.edges)
[(0, 1)]
"""
graph_class = self.to_undirected_class()
if as_view is True:
return nx.graphviews.generic_graph_view(self, Graph)
# deepcopy when not a view
G = Graph()
G.graph.update(deepcopy(self.graph))
G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
if reciprocal is True:
G.add_edges_from((u, v, deepcopy(d))
for u, nbrs in self._adj.items()
for v, d in nbrs.items()
if v in self._pred[u])
else:
G.add_edges_from((u, v, deepcopy(d))
for u, nbrs in self._adj.items()
for v, d in nbrs.items())
return G
def to_undirected(self, reciprocal=False, as_view=False):
"""Returns an undirected representation of the digraph.
Parameters
----------
reciprocal : bool (optional)
If True only keep edges that appear in both directions
in the original digraph.
as_view : bool (optional, default=False)
If True return an undirected view of the original directed graph.
Returns
-------
G : Graph
An undirected graph with the same name and nodes and
with edge (u, v, data) if either (u, v, data) or (v, u, data)
is in the digraph. If both edges exist in digraph and
their edge data is different, only one edge is created
with an arbitrary choice of which edge data to use.
You must check and correct for this manually if desired.
See Also
--------
Graph, copy, add_edge, add_edges_from
Notes
-----
If edges in both directions (u, v) and (v, u) exist in the
graph, attributes for the new undirected edge will be a combination of
the attributes of the directed edges. The edge data is updated
in the (arbitrary) order that the edges are encountered. For
more customized control of the edge attributes use add_edge().
This returns a "deepcopy" of the edge, node, and
graph attributes which attempts to completely copy
all of the data and references.
This is in contrast to the similar G=DiGraph(D) which returns a
shallow copy of the data.
See the Python copy module for more information on shallow
and deep copies, https://docs.python.org/2/library/copy.html.
Warning: If you have subclassed DiGraph to use dict-like objects
in the data structure, those changes do not transfer to the
Graph created by this method.
Examples
--------
>>> G = nx.path_graph(2) # or MultiGraph, etc
>>> H = G.to_directed()
>>> list(H.edges)
[(0, 1), (1, 0)]
>>> G2 = H.to_undirected()
>>> list(G2.edges)
[(0, 1)]
"""
graph_class = self.to_undirected_class()
if as_view is True:
return nx.graphviews.generic_graph_view(self, Graph)
# deepcopy when not a view
G = Graph()
G.graph.update(deepcopy(self.graph))
G.add_nodes_from((n, deepcopy(d)) for n, d in self._node.items())
if reciprocal is True:
G.add_edges_from((u, v, deepcopy(d))
for u, nbrs in self._adj.items()
for v, d in nbrs.items() if v in self._pred[u])
else:
G.add_edges_from((u, v, deepcopy(d))
for u, nbrs in self._adj.items()
for v, d in nbrs.items())
return G