def testRealizeDegreeSequence(self):
# Test case insensitivity of options too
g = Graph.Realize_Degree_Sequence(
[1, 1],
None,
"simPLE",
"smallest",
)
self.assertFalse(g.is_directed())
self.assertTrue(g.degree() == [1, 1])
# Not implemented, should fail
self.assertRaises(NotImplementedError, Graph.Realize_Degree_Sequence,
[1, 1], None, "loops", "largest")
g = Graph.Realize_Degree_Sequence(
[1, 1],
None,
"all",
"largest",
)
self.assertFalse(g.is_directed())
self.assertTrue(g.degree() == [1, 1])
g = Graph.Realize_Degree_Sequence(
[1, 1],
None,
"multi",
"index",
)
self.assertFalse(g.is_directed())
self.assertTrue(g.degree() == [1, 1])
g = Graph.Realize_Degree_Sequence(
[1, 1],
[1, 1],
"simple",
"largest",
)
self.assertTrue(g.is_directed())
self.assertTrue(g.indegree() == [1, 1])
self.assertTrue(g.outdegree() == [1, 1])
# Not implemented, should fail
self.assertRaises(NotImplementedError, Graph.Realize_Degree_Sequence,
[1, 1], [1, 1], "multi", "largest")
self.assertRaises(ValueError, Graph.Realize_Degree_Sequence, [1, 1],
[1, 1], "should_fail", "index")
self.assertRaises(ValueError, Graph.Realize_Degree_Sequence, [1, 1],
[1, 1], "multi", "should_fail")
# Degree sequence of Zachary karate club, using optional arguments
zachary = Graph.Famous("zachary")
degrees = zachary.degree()
g = Graph.Realize_Degree_Sequence(degrees)
self.assertFalse(g.is_directed())
self.assertTrue(g.degree() == degrees)
def testGraphGetEids(self):
g = Graph.Famous("petersen")
eids = g.get_eids(pairs=[(0, 1), (0, 5), (1, 6), (4, 9), (8, 6)])
self.assertTrue(eids == [0, 2, 4, 9, 12])
eids = g.get_eids(path=[0, 1, 2, 3, 4])
self.assertTrue(eids == [0, 3, 5, 7])
eids = g.get_eids(pairs=[(7, 9), (9, 6)], path=[7, 9, 6])
self.assertTrue(eids == [14, 13, 14, 13])
self.assertRaises(InternalError, g.get_eids, pairs=[(0, 1), (0, 2)])
def testClear(self):
g = Graph.Famous("petersen")
g["name"] = list("petersen")
# Clearing the graph
g.clear()
self.assertEqual(0, g.vcount())
self.assertEqual(0, g.ecount())
self.assertEqual([], g.attributes())
def testVertexNameIndexingBytes(self):
g = Graph.Famous("bull")
g.vs["name"] = [b"foo", b"bar", b"baz", b"fred", b"thud"]
self.assertTrue(g.degree(b"bar") == 3)
self.assertTrue(g.degree([b"bar", b"fred", 0]) == [3, 1, 2])
g.vs[2]["name"] = b"quack"
self.assertRaises(ValueError, g.degree, b"baz")
self.assertTrue(g.degree(b"quack") == 3)
del g.vs["name"]
self.assertRaises(ValueError, g.degree, [b"bar", b"thud", 0])
def testDeleteEdges(self):
g = Graph.Famous("petersen")
g.vs["name"] = list("ABCDEFGHIJ")
el = g.get_edgelist()
self.assertEqual(15, g.ecount())
# Deleting single edge
g.delete_edges(14)
el[14:] = []
self.assertEqual(14, g.ecount())
self.assertEqual(el, g.get_edgelist())
# Deleting multiple edges
g.delete_edges([2, 5, 7])
el[7:8] = []
el[5:6] = []
el[2:3] = []
self.assertEqual(11, g.ecount())
self.assertEqual(el, g.get_edgelist())
# Deleting edge object
g.es[6].delete()
el[6:7] = []
self.assertEqual(10, g.ecount())
self.assertEqual(el, g.get_edgelist())
# Deleting edge sequence object
g.es[1:4].delete()
el[1:4] = []
self.assertEqual(7, g.ecount())
self.assertEqual(el, g.get_edgelist())
# Deleting edges by IDs
g.delete_edges([(2, 7), (5, 8)])
el[4:5] = []
el[1:2] = []
self.assertEqual(5, g.ecount())
self.assertEqual(el, g.get_edgelist())
# Deleting edges by names
g.delete_edges([("D", "I"), ("G", "I")])
el[3:4] = []
el[1:2] = []
self.assertEqual(3, g.ecount())
self.assertEqual(el, g.get_edgelist())
# Deleting nonexistent edges
self.assertRaises(ValueError, g.delete_edges, [(0, 2)])
self.assertRaises(ValueError, g.delete_edges, [("A", "C")])
self.assertRaises(ValueError, g.delete_edges, [(0, 15)])
# Delete all edges
g.delete_edges()
self.assertEqual(0, g.ecount())
def testGraphGetEid(self):
g = Graph.Famous("petersen")
g.vs["name"] = list("ABCDEFGHIJ")
edges_to_ids = dict((v, k) for k, v in enumerate(g.get_edgelist()))
for (source, target), edge_id in list(edges_to_ids.items()):
source_name, target_name = g.vs[(source, target)]["name"]
self.assertEqual(edge_id, g.get_eid(source, target))
self.assertEqual(edge_id, g.get_eid(source_name, target_name))
self.assertRaises(InternalError, g.get_eid, 0, 11)
self.assertRaises(ValueError, g.get_eid, "A", "K")
def testInvalidAttributeNames(self):
g = Graph.Famous("bull")
for attr_name in [None, 2.654, unittest, str]:
self.assertRaises(TypeError, g.vs.__setitem__, attr_name, "foo")
self.assertRaises(TypeError, g.vs.__getitem__, attr_name, "foo")
self.assertRaises(TypeError, g.vs[0].__setitem__, attr_name, "foo")
self.assertRaises(TypeError, g.vs[0].__getitem__, attr_name, "foo")
self.assertRaises(TypeError, g.es.__setitem__, attr_name, "foo")
self.assertRaises(TypeError, g.es.__getitem__, attr_name, "foo")
self.assertRaises(TypeError, g.es[0].__setitem__, attr_name, "foo")
self.assertRaises(TypeError, g.es[0].__getitem__, attr_name, "foo")
def testMaximumCardinalitySearch(self):
g = Graph()
alpha, alpham1 = g.maximum_cardinality_search()
self.assertListEqual([], alpha)
self.assertListEqual([], alpham1)
g = Graph.Famous("petersen")
alpha, alpham1 = g.maximum_cardinality_search()
print(repr(alpha), repr(alpham1))
self.assert_valid_maximum_cardinality_search_result(g, alpha, alpham1)
g = Graph.GRG(100, 0.2)
alpha, alpham1 = g.maximum_cardinality_search()
self.assert_valid_maximum_cardinality_search_result(g, alpha, alpham1)
def testInfomap(self):
g = Graph.Famous("zachary")
cl = g.community_infomap()
self.assertAlmostEqual(cl.codelength, 4.60605, places=3)
self.assertAlmostEqual(cl.q, 0.40203, places=3)
self.assertMembershipsEqual(
cl,
[1, 1, 1, 1, 2, 2, 2, 1, 0, 1, 2, 1, 1, 1, 0, 0, 2, 1, 0, 1, 0, 1]
+ [0] * 12,
)
# Smoke testing with vertex and edge weights
v_weights = [random.randint(1, 5) for _ in range(g.vcount())]
e_weights = [random.randint(1, 5) for _ in range(g.ecount())]
cl = g.community_infomap(edge_weights=e_weights)
cl = g.community_infomap(vertex_weights=v_weights)
cl = g.community_infomap(edge_weights=e_weights,
vertex_weights=v_weights)
def testUnhashableVertexNames(self):
g = Graph.Famous("bull")
g.vs["name"] = [str(x) for x in range(4)]
value = "this is not hashable".split()
g.vs[2]["name"] = value
# Trigger an indexing by doing a lookup by name
try:
g.vs.find("3")
err = None
except Exception as ex:
err = ex
# Check the exception
self.assertTrue(isinstance(err, RuntimeError))
if sys.version_info >= (3, 4):
self.assertTrue(repr(value) in str(err))
def testOptimalModularity(self):
try:
g = Graph.Famous("bull")
cl = g.community_optimal_modularity()
self.assertTrue(len(cl) == 2)
self.assertMembershipsEqual(cl, [0, 0, 1, 0, 1])
self.assertAlmostEqual(cl.q, 0.08, places=7)
ws = [i % 5 for i in range(g.ecount())]
cl = g.community_optimal_modularity(weights=ws)
self.assertAlmostEqual(cl.q,
g.modularity(cl.membership, weights=ws),
places=7)
g = Graph.Famous("zachary")
cl = g.community_optimal_modularity()
self.assertTrue(len(cl) == 4)
self.assertMembershipsEqual(
cl,
[
0,
0,
0,
0,
1,
1,
1,
0,
2,
2,
1,
0,
0,
0,
2,
2,
1,
0,
2,
0,
2,
0,
2,
3,
3,
3,
2,
3,
3,
2,
2,
3,
2,
2,
],
)
self.assertAlmostEqual(cl.q, 0.4197896, places=7)
ws = [2 + (i % 3) for i in range(g.ecount())]
cl = g.community_optimal_modularity(weights=ws)
self.assertAlmostEqual(cl.q,
g.modularity(cl.membership, weights=ws),
places=7)
except NotImplementedError:
# Well, meh
pass
def testFamous(self):
g = Graph.Famous("tutte")
self.assertTrue(g.vcount() == 46 and g.ecount() == 69)
self.assertRaises(InternalError, Graph.Famous, "unknown")
def testLCF(self):
g1 = Graph.LCF(12, (5, -5), 6)
g2 = Graph.Famous("Franklin")
self.assertTrue(g1.isomorphic(g2))
self.assertRaises(InternalError, Graph.LCF, 12, (5, -5), -3)
out["global clustering"] = g.transitivity_undirected()
out["local clustering"] = g.transitivity_avglocal_undirected()
return out
def igraph_path(g, nodes, labels=None, desc=None):
"""Display edge directions in path of nodes"""
return " ".join("[{node}] {arrow}".format(node=u if labels is None else (
labels[u] if desc is None else desc[labels[u]]),
arrow="->" if g[u, v] else (
"<-" if g[v, u] else ""))
for u, v in zip(nodes, nodes[1:] + nodes[:1]))
if False: # randomly explore igraph
import igraph
p = igraph.plot(Graph.Famous("petersen"))
p.show()
Graph.show(Graph.Famous("petersen"))
_colors = [
'darkred', 'darkgreen', 'darkblue', 'indigo', 'red', 'lime', 'blue',
'blueviolet', 'salmon', 'lawngreen', 'slateblue', 'mediumpurple',
'chocolate', 'forestgreen', 'cyan', 'magenta', 'orange', 'teal'
]
g = Graph.Barabasi(n=20, m=1)
i = g.community_infomap()
pal = igraph.drawing.colors.ClusterColoringPalette(len(i))
g.vs['color'] = pal.get_many(i.membership)
plot(g)
def test_zachary():
test(IGraphWrapper(Graph.Famous("Zachary")))
