def testSpinglass(self):
g = Graph.Full(5) + Graph.Full(5) + Graph.Full(5)
g += [(0, 5), (5, 10), (10, 0)]
# Spinglass community detection is a bit unstable, so run it three times
ok = False
for i in range(3):
cl = g.community_spinglass()
if self.reindexMembership(cl) == [
0,
0,
0,
0,
0,
1,
1,
1,
1,
1,
2,
2,
2,
2,
2,
]:
ok = True
break
self.assertTrue(ok)
def testWalktrap(self):
g = Graph.Full(5) + Graph.Full(5) + Graph.Full(5)
g += [(0, 5), (5, 10), (10, 0)]
cl = g.community_walktrap().as_clustering()
self.assertMembershipsEqual(
cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2])
cl = g.community_walktrap(steps=3).as_clustering()
self.assertMembershipsEqual(
cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2])
def testEigenvector(self):
g = Graph.Full(5) + Graph.Full(5)
g.add_edges([(0, 5)])
cl = g.community_leading_eigenvector()
self.assertMembershipsEqual(cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
self.assertAlmostEqual(cl.q, 0.4523, places=3)
cl = g.community_leading_eigenvector(2)
self.assertMembershipsEqual(cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
self.assertAlmostEqual(cl.q, 0.4523, places=3)
def testModularity(self):
g = Graph.Full(5) + Graph.Full(5)
g.add_edges([(0, 5)])
cl = [0] * 5 + [1] * 5
self.assertAlmostEqual(g.modularity(cl), 0.4523, places=3)
ws = [1] * 21
self.assertAlmostEqual(g.modularity(cl, ws), 0.4523, places=3)
ws = [2] * 21
self.assertAlmostEqual(g.modularity(cl, ws), 0.4523, places=3)
ws = [2] * 10 + [1] * 11
self.assertAlmostEqual(g.modularity(cl, ws), 0.4157, places=3)
self.assertRaises(InternalError, g.modularity, cl, ws[0:20])
def testClauset(self):
# Two cliques of size 5 with one connecting edge
g = Graph.Full(5) + Graph.Full(5)
g.add_edges([(0, 5)])
cl = g.community_fastgreedy().as_clustering()
self.assertMembershipsEqual(cl, [0, 0, 0, 0, 0, 1, 1, 1, 1, 1])
self.assertAlmostEqual(cl.q, 0.4523, places=3)
# Lollipop, weighted
g = Graph.Full(4) + Graph.Full(2)
g.add_edges([(3, 4)])
weights = [1, 1, 1, 1, 1, 1, 10, 10]
cl = g.community_fastgreedy(weights).as_clustering()
self.assertMembershipsEqual(cl, [0, 0, 0, 1, 1, 1])
self.assertAlmostEqual(cl.q, 0.1708, places=3)
# Same graph, different weights
g.es["weight"] = [3] * g.ecount()
cl = g.community_fastgreedy("weight").as_clustering()
self.assertMembershipsEqual(cl, [0, 0, 0, 0, 1, 1])
self.assertAlmostEqual(cl.q, 0.1796, places=3)
# Disconnected graph
g = Graph.Full(4) + Graph.Full(4) + Graph.Full(3) + Graph.Full(2)
cl = g.community_fastgreedy().as_clustering()
self.assertMembershipsEqual(cl,
[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 3, 3])
# Empty graph
g = Graph(20)
cl = g.community_fastgreedy().as_clustering()
self.assertMembershipsEqual(cl, list(range(g.vcount())))
def testPathLengthHist(self):
g = Graph.Tree(15, 2)
h = g.path_length_hist()
self.assertTrue(h.unconnected == 0)
self.assertTrue([(int(value), x) for value, _, x in h.bins()] == [(
1, 14), (2, 19), (3, 20), (4, 20), (5, 16), (6, 16)])
g = Graph.Full(5) + Graph.Full(4)
h = g.path_length_hist()
self.assertTrue(h.unconnected == 20)
g.to_directed()
h = g.path_length_hist()
self.assertTrue(h.unconnected == 40)
h = g.path_length_hist(False)
self.assertTrue(h.unconnected == 20)
def testIsChordal(self):
g = Graph()
self.assertTrue(g.is_chordal())
g = Graph.Full(3)
self.assertTrue(g.is_chordal())
g = Graph.Full(5)
self.assertTrue(g.is_chordal())
g = Graph.Ring(4)
self.assertFalse(g.is_chordal())
g = Graph.Ring(5)
self.assertFalse(g.is_chordal())
def testFull(self):
g = Graph.Full(20, directed=True)
el = g.get_edgelist()
el.sort()
self.assertTrue(
g.get_edgelist() == [(x, y) for x in range(20) for y in range(20) if x != y]
)
def is_supported():
"""Returns ``True`` if the version of igraph supports the ``pairs``
keyword argument for the Jaccard similarity, ``False`` otherwise."""
try:
g = Graph.Full(2)
g.similarity_jaccard(pairs=(0, 1))
return True
except:
return False
def testMassEdgeAttributeAssignment(self):
g = Graph.Full(5)
g.es.set_attribute_values("name", list(range(10)))
self.assertTrue(g.es.get_attribute_values("name") == list(range(10)))
g.es["name"] = list(range(10, 20))
self.assertTrue(g.es["name"] == list(range(10, 20)))
g.es["name2"] = (1, 2, 3, 4, 6, 1, 2, 3, 4, 6)
self.assertTrue(g.es["name2"] == [1, 2, 3, 4, 6, 1, 2, 3, 4, 6])
g.es.set_attribute_values("name", [2])
self.assertTrue(g.es["name"] == [2] * 10)
def testMassVertexAttributeAssignment(self):
g = Graph.Full(5)
g.vs.set_attribute_values("name", list(range(5)))
self.assertTrue(g.vs.get_attribute_values("name") == list(range(5)))
g.vs["name"] = list(range(5, 10))
self.assertTrue(g.vs["name"] == list(range(5, 10)))
g.vs["name2"] = (1, 2, 3, 4, 6)
self.assertTrue(g.vs["name2"] == [1, 2, 3, 4, 6])
g.vs.set_attribute_values("name", [2])
self.assertTrue(g.vs["name"] == [2] * 5)
def testIsChordalWithHint(self):
g = Graph()
alpha, _ = g.maximum_cardinality_search()
self.assertTrue(g.is_chordal(alpha=alpha))
g = Graph.Full(3)
alpha, _ = g.maximum_cardinality_search()
self.assertTrue(g.is_chordal(alpha=alpha))
g = Graph.Ring(5)
alpha, _ = g.maximum_cardinality_search()
self.assertFalse(g.is_chordal(alpha=alpha))
g = Graph.Ring(4)
_, alpham1 = g.maximum_cardinality_search()
self.assertFalse(g.is_chordal(alpham1=alpham1))
g = Graph.Full(5)
_, alpham1 = g.maximum_cardinality_search()
self.assertTrue(g.is_chordal(alpham1=alpham1))
def testChordalCompletion(self):
g = Graph()
self.assertListEqual([], g.chordal_completion())
g = Graph.Full(3)
self.assertListEqual([], g.chordal_completion())
g = Graph.Full(5)
self.assertListEqual([], g.chordal_completion())
g = Graph.Ring(4)
cc = g.chordal_completion()
self.assertEqual(len(cc), 1)
g += cc
self.assertTrue(g.is_chordal())
self.assertListEqual([], g.chordal_completion())
g = Graph.Ring(5)
cc = g.chordal_completion()
self.assertEqual(len(cc), 2)
g += cc
self.assertListEqual([], g.chordal_completion())
def testEdgeAttributes(self):
g = Graph.Full(5)
g.es[0]["name"] = "first"
self.assertTrue(g.es[0]["name"] == "first")
del g.es["name"]
self.assertRaises(KeyError, g.es.__getitem__, "name")
g.es[0]["name"] = "second"
g.es[0]["date"] = "2007-12-17"
ans = g.es[0].attribute_names()
ans.sort()
self.assertTrue(ans == ["date", "name"])
attrs = g.es[0].attributes()
self.assertTrue(attrs == {"name": "second", "date": "2007-12-17"})
def testEdgeBetweenness(self):
# Full graph, no weights
g = Graph.Full(5)
cl = g.community_edge_betweenness().as_clustering()
self.assertMembershipsEqual(cl, [0] * 5)
# Full graph with weights
g.es["weight"] = 1
g[0, 1] = g[1, 2] = g[2, 0] = g[3, 4] = 10
# We need to specify the desired cluster count explicitly; this is
# because edge betweenness-based detection does not play well with
# modularity-based cluster count selection (the edge weights have
# different semantics) so we need to give igraph a hint
cl = g.community_edge_betweenness(weights="weight").as_clustering(n=2)
self.assertMembershipsEqual(cl, [0, 0, 0, 1, 1])
self.assertAlmostEqual(cl.q, 0.2750, places=3)
def testLocalTransitivity(self):
self.assertTrue(self.gfull.transitivity_local_undirected() == [1.0] *
self.gfull.vcount())
self.assertTrue(
self.tree.transitivity_local_undirected(mode="zero") == [0.0] *
self.tree.vcount())
transitivity = self.g.transitivity_local_undirected(mode="zero")
self.assertAlmostEqual(2 / 3, transitivity[0], places=4)
self.assertAlmostEqual(2 / 3, transitivity[1], places=4)
self.assertEqual(1, transitivity[2])
self.assertEqual(1, transitivity[3])
g = Graph.Full(4) + 1 + [(0, 4)]
g.es["weight"] = [1, 1, 1, 1, 1, 1, 5]
self.assertAlmostEqual(g.transitivity_local_undirected(
0, weights="weight"),
0.25,
places=4)
def testAuto(self):
def layout_test(graph, test_with_dims=(2, 3)):
lo = graph.layout("auto")
self.assertTrue(isinstance(lo, Layout))
self.assertEqual(len(lo[0]), 2)
for dim in test_with_dims:
lo = graph.layout("auto", dim=dim)
self.assertTrue(isinstance(lo, Layout))
self.assertEqual(len(lo[0]), dim)
return lo
g = Graph.Barabasi(10)
layout_test(g)
g = Graph.GRG(101, 0.2)
del g.vs["x"]
del g.vs["y"]
layout_test(g)
g = Graph.Full(10) * 2
layout_test(g)
g["layout"] = "graphopt"
layout_test(g, test_with_dims=())
g.vs["x"] = list(range(20))
g.vs["y"] = list(range(20, 40))
layout_test(g, test_with_dims=())
del g["layout"]
lo = layout_test(g, test_with_dims=(2,))
self.assertEqual(
[tuple(item) for item in lo],
list(zip(list(range(20)), list(range(20, 40)))),
)
g.vs["z"] = list(range(40, 60))
lo = layout_test(g)
self.assertEqual(
[tuple(item) for item in lo],
list(zip(list(range(20)), list(range(20, 40)), list(range(40, 60)))),
)
def testDeleteVertices(self):
g = Graph([(0, 1), (1, 2), (2, 3), (0, 2), (3, 4), (4, 5)])
self.assertEqual(6, g.vcount())
self.assertEqual(6, g.ecount())
# Delete a single vertex
g.delete_vertices(4)
self.assertEqual(5, g.vcount())
self.assertEqual(4, g.ecount())
# Delete multiple vertices
g.delete_vertices([1, 3])
self.assertEqual(3, g.vcount())
self.assertEqual(1, g.ecount())
# Delete a vertex sequence
g.delete_vertices(g.vs[:2])
self.assertEqual(1, g.vcount())
self.assertEqual(0, g.ecount())
# Delete a single vertex object
g.vs[0].delete()
self.assertEqual(0, g.vcount())
self.assertEqual(0, g.ecount())
# Delete vertices by name
g = Graph.Full(4)
g.vs["name"] = ["spam", "bacon", "eggs", "ham"]
self.assertEqual(4, g.vcount())
g.delete_vertices("spam")
self.assertEqual(3, g.vcount())
g.delete_vertices(["bacon", "ham"])
self.assertEqual(1, g.vcount())
# Deleting a nonexistent vertex
self.assertRaises(ValueError, g.delete_vertices, "no-such-vertex")
self.assertRaises(InternalError, g.delete_vertices, 2)
# Delete all vertices
g.delete_vertices()
self.assertEqual(0, g.vcount())
class BiconnectedComponentTests(unittest.TestCase):
g1 = Graph.Full(10)
g2 = Graph(5, [(0, 1), (1, 2), (2, 3), (3, 4)])
g3 = Graph(6, [(0, 1), (1, 2), (2, 3), (3, 0), (2, 4), (2, 5), (4, 5)])
def testBiconnectedComponents(self):
s = self.g1.biconnected_components()
self.assertTrue(len(s) == 1 and s[0] == list(range(10)))
s, ap = self.g1.biconnected_components(True)
self.assertTrue(len(s) == 1 and s[0] == list(range(10)))
s = self.g3.biconnected_components()
self.assertTrue(
len(s) == 2 and s[0] == [2, 4, 5] and s[1] == [0, 1, 2, 3])
s, ap = self.g3.biconnected_components(True)
self.assertTrue(
len(s) == 2 and s[0] == [2, 4, 5] and s[1] == [0, 1, 2, 3]
and ap == [2])
def testArticulationPoints(self):
self.assertTrue(self.g1.articulation_points() == [])
self.assertTrue(self.g2.cut_vertices() == [1, 2, 3])
self.assertTrue(self.g3.articulation_points() == [2])
def testCohesiveBlocks1(self):
# Taken from the igraph R manual
g = Graph.Full(4) + Graph(2) + [(3, 4), (4, 5), (4, 2)]
g *= 3
g += [(0, 6), (1, 7), (0, 12), (4, 0), (4, 1)]
cbs = g.cohesive_blocks()
self.genericTests(cbs)
self.assertEqual(
sorted(list(cbs)),
[
list(range(0, 5)),
list(range(18)),
[0, 1, 2, 3, 4, 6, 7, 8, 9, 10],
list(range(6, 10)),
list(range(12, 16)),
list(range(12, 17)),
],
)
self.assertEqual(cbs.cohesions(), [1, 2, 2, 4, 3, 3])
self.assertEqual(
cbs.max_cohesions(),
[4, 4, 4, 4, 4, 1, 3, 3, 3, 3, 2, 1, 3, 3, 3, 3, 2, 1])
self.assertEqual(cbs.parents(), [None, 0, 0, 1, 2, 1])
def testGraphAttributes(self):
g = Graph.Full(5)
g["date"] = "2005-12-17"
self.assertTrue(g["date"] == "2005-12-17")
del g["date"]
self.assertRaises(KeyError, g.__getitem__, "date")
class SimplePropertiesTests(unittest.TestCase):
gfull = Graph.Full(10)
gempty = Graph(10)
g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3)])
gdir = Graph(4, [(0, 1), (0, 2), (1, 2), (2, 1), (0, 3), (1, 3), (3, 0)],
directed=True)
tree = Graph.Tree(14, 3)
def testDensity(self):
self.assertAlmostEqual(1.0, self.gfull.density(), places=5)
self.assertAlmostEqual(0.0, self.gempty.density(), places=5)
self.assertAlmostEqual(5 / 6, self.g.density(), places=5)
self.assertAlmostEqual(1 / 2, self.g.density(True), places=5)
self.assertAlmostEqual(7 / 12, self.gdir.density(), places=5)
self.assertAlmostEqual(7 / 16, self.gdir.density(True), places=5)
self.assertAlmostEqual(1 / 7, self.tree.density(), places=5)
def testDiameter(self):
self.assertTrue(self.gfull.diameter() == 1)
self.assertTrue(self.gempty.diameter(unconn=False) == inf)
self.assertTrue(self.gempty.diameter(unconn=False) == inf)
self.assertTrue(self.g.diameter() == 2)
self.assertTrue(self.gdir.diameter(False) == 2)
self.assertTrue(self.gdir.diameter() == 3)
self.assertTrue(self.tree.diameter() == 5)
s, t, d = self.tree.farthest_points()
self.assertTrue((s == 13 or t == 13) and d == 5)
self.assertTrue(
self.gempty.farthest_points(unconn=False) == (None, None, inf))
d = self.tree.get_diameter()
self.assertTrue(d[0] == 13 or d[-1] == 13)
weights = [1, 1, 1, 5, 1, 5, 1, 1, 1, 1, 1, 1, 5]
self.assertTrue(self.tree.diameter(weights=weights) == 15)
d = self.tree.farthest_points(weights=weights)
self.assertTrue(d == (13, 6, 15) or d == (6, 13, 15))
def testEccentricity(self):
self.assertEqual(self.gfull.eccentricity(), [1] * self.gfull.vcount())
self.assertEqual(self.gempty.eccentricity(),
[0] * self.gempty.vcount())
self.assertEqual(self.g.eccentricity(), [1, 1, 2, 2])
self.assertEqual(self.gdir.eccentricity(), [1, 2, 3, 2])
self.assertEqual(self.tree.eccentricity(),
[3, 3, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5])
self.assertEqual(Graph().eccentricity(), [])
def testRadius(self):
self.assertEqual(self.gfull.radius(), 1)
self.assertEqual(self.gempty.radius(), 0)
self.assertEqual(self.g.radius(), 1)
self.assertEqual(self.gdir.radius(), 1)
self.assertEqual(self.tree.radius(), 3)
self.assertTrue(isnan(Graph().radius()))
def testTransitivity(self):
self.assertTrue(self.gfull.transitivity_undirected() == 1.0)
self.assertTrue(self.tree.transitivity_undirected() == 0.0)
self.assertTrue(self.g.transitivity_undirected() == 0.75)
def testLocalTransitivity(self):
self.assertTrue(self.gfull.transitivity_local_undirected() == [1.0] *
self.gfull.vcount())
self.assertTrue(
self.tree.transitivity_local_undirected(mode="zero") == [0.0] *
self.tree.vcount())
transitivity = self.g.transitivity_local_undirected(mode="zero")
self.assertAlmostEqual(2 / 3, transitivity[0], places=4)
self.assertAlmostEqual(2 / 3, transitivity[1], places=4)
self.assertEqual(1, transitivity[2])
self.assertEqual(1, transitivity[3])
g = Graph.Full(4) + 1 + [(0, 4)]
g.es["weight"] = [1, 1, 1, 1, 1, 1, 5]
self.assertAlmostEqual(g.transitivity_local_undirected(
0, weights="weight"),
0.25,
places=4)
def testAvgLocalTransitivity(self):
self.assertTrue(self.gfull.transitivity_avglocal_undirected() == 1.0)
self.assertTrue(self.tree.transitivity_avglocal_undirected() == 0.0)
self.assertAlmostEqual(self.g.transitivity_avglocal_undirected(),
5 / 6.0,
places=4)
def testModularity(self):
g = Graph.Full(5) + Graph.Full(5)
g.add_edges([(0, 5)])
cl = [0] * 5 + [1] * 5
self.assertAlmostEqual(g.modularity(cl), 0.4523, places=3)
ws = [1] * 21
self.assertAlmostEqual(g.modularity(cl, ws), 0.4523, places=3)
ws = [2] * 21
self.assertAlmostEqual(g.modularity(cl, ws), 0.4523, places=3)
ws = [2] * 10 + [1] * 11
self.assertAlmostEqual(g.modularity(cl, ws), 0.4157, places=3)
self.assertRaises(InternalError, g.modularity, cl, ws[0:20])
def testDataFrame(self):
edges = pd.DataFrame(
[["C", "A", 0.4], ["A", "B", 0.1]], columns=[0, 1, "weight"]
)
g = Graph.DataFrame(edges, directed=False)
self.assertTrue(g.es["weight"] == [0.4, 0.1])
vertices = pd.DataFrame(
[["A", "blue"], ["B", "yellow"], ["C", "blue"]], columns=[0, "color"]
)
g = Graph.DataFrame(edges, directed=True, vertices=vertices)
self.assertTrue(g.vs["name"] == ["A", "B", "C"])
self.assertTrue(g.vs["color"] == ["blue", "yellow", "blue"])
self.assertTrue(g.es["weight"] == [0.4, 0.1])
# Issue #347
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
vertices = pd.DataFrame(
{"node": [1, 2, 3, 4, 5, 6], "label": ["1", "2", "3", "4", "5", "6"]}
)[["node", "label"]]
g = Graph.DataFrame(
edges,
directed=True,
vertices=vertices
)
self.assertTrue(g.vs["name"] == [1, 2, 3, 4, 5, 6])
self.assertTrue(g.vs["label"] == ["1", "2", "3", "4", "5", "6"])
# Vertex ids
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
g = Graph.DataFrame(edges)
self.assertTrue(g.vcount() == 6)
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
g = Graph.DataFrame(edges, use_vids=True)
self.assertTrue(g.vcount() == 7)
# Graph clone
g = Graph.Full(n=100, directed=True, loops=True)
g.vs["name"] = [f"v{i}" for i in range(g.vcount())]
g.vs["x"] = [float(i) for i in range(g.vcount())]
g.es["w"] = [1.0] * g.ecount()
df_edges = g.get_edge_dataframe()
df_vertices = g.get_vertex_dataframe()
g_clone = Graph.DataFrame(df_edges, g.is_directed(), df_vertices, True)
self.assertTrue(df_edges.equals(g_clone.get_edge_dataframe()))
self.assertTrue(df_vertices.equals(g_clone.get_vertex_dataframe()))
# Invalid input
with self.assertRaisesRegex(ValueError, "two columns"):
edges = pd.DataFrame({"source": [1, 2, 3]})
Graph.DataFrame(edges)
with self.assertRaisesRegex(ValueError, "one column"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
Graph.DataFrame(edges, vertices=pd.DataFrame())
with self.assertRaisesRegex(TypeError, "integers"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]}).astype(str)
Graph.DataFrame(edges, use_vids=True)
with self.assertRaisesRegex(ValueError, "negative"):
edges = -pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
Graph.DataFrame(edges, use_vids=True)
with self.assertRaisesRegex(TypeError, "integers"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
vertices = pd.DataFrame({0: [1, 2, 3]}, index=["1", "2", "3"])
Graph.DataFrame(edges, vertices=vertices, use_vids=True)
with self.assertRaisesRegex(ValueError, "negative"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
vertices = pd.DataFrame({0: [1, 2, 3]}, index=[-1, 2, 3])
Graph.DataFrame(edges, vertices=vertices, use_vids=True)
with self.assertRaisesRegex(ValueError, "sequence"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
vertices = pd.DataFrame({0: [1, 2, 3]}, index=[1, 2, 4])
Graph.DataFrame(edges, vertices=vertices, use_vids=True)
with self.assertRaisesRegex(TypeError, "integers"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
vertices = pd.DataFrame({0: [1, 2, 3]}, index=pd.MultiIndex.from_tuples([(1, 1), (2, 2), (3, 3)]))
Graph.DataFrame(edges, vertices=vertices, use_vids=True)
with self.assertRaisesRegex(ValueError, "unique"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
vertices = pd.DataFrame({0: [1, 2, 2]})
Graph.DataFrame(edges, vertices=vertices)
with self.assertRaisesRegex(ValueError, "already contains"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
vertices = pd.DataFrame({0: [1, 2, 3], "name": [1, 2, 2]})
Graph.DataFrame(edges, vertices=vertices)
with self.assertRaisesRegex(ValueError, "missing from"):
edges = pd.DataFrame({"source": [1, 2, 3], "target": [4, 5, 6]})
vertices = pd.DataFrame({0: [1, 2, 3]}, index=[0, 1, 2])
Graph.DataFrame(edges, vertices=vertices, use_vids=True)
def _get_mst(self):
full_graph = Graph.Full(self.n0)
factor = 1e5 # since small weights lead to MST problem
weights = [factor * self.distance[self._s((edge.source,edge.target))] for edge in full_graph.es]
G = full_graph.spanning_tree(weights).as_undirected()
return G.get_edgelist()
def testCoreness(self):
g = Graph.Full(4) + Graph(4) + [(0, 4), (1, 5), (2, 6), (3, 7)]
self.assertEqual(g.coreness("A"), [3, 3, 3, 3, 1, 1, 1, 1])
def testLocalTransitivityFull(self):
trans = Graph.Full(10).transitivity_local_undirected()
self.assertTrue(trans == [1.0] * 10)
class DegreeTests(unittest.TestCase):
gfull = Graph.Full(10)
gempty = Graph(10)
g = Graph(4, [(0, 1), (0, 2), (1, 2), (0, 3), (1, 3), (0, 0)])
gdir = Graph(4, [(0, 1), (0, 2), (1, 2), (2, 1), (0, 3), (1, 3), (3, 0)],
directed=True)
tree = Graph.Tree(10, 3)
def testKnn(self):
knn, knnk = self.gfull.knn()
self.assertTrue(knn == [9.0] * 10)
self.assertAlmostEqual(knnk[8], 9.0, places=6)
# knn works for simple graphs only -- self.g is not simple
self.assertRaises(InternalError, self.g.knn)
# Okay, simplify it and then go on
g = self.g.copy()
g.simplify()
knn, knnk = g.knn()
diff = max(abs(a - b) for a, b in zip(knn, [7 / 3.0, 7 / 3.0, 3, 3]))
self.assertAlmostEqual(diff, 0.0, places=6)
self.assertEqual(len(knnk), 3)
self.assertAlmostEqual(knnk[1], 3, places=6)
self.assertAlmostEqual(knnk[2], 7 / 3.0, places=6)
def testDegree(self):
self.assertTrue(self.gfull.degree() == [9] * 10)
self.assertTrue(self.gempty.degree() == [0] * 10)
self.assertTrue(self.g.degree(loops=False) == [3, 3, 2, 2])
self.assertTrue(self.g.degree() == [5, 3, 2, 2])
self.assertTrue(self.gdir.degree(mode=IN) == [1, 2, 2, 2])
self.assertTrue(self.gdir.degree(mode=OUT) == [3, 2, 1, 1])
self.assertTrue(self.gdir.degree(mode=ALL) == [4, 4, 3, 3])
vs = self.gdir.vs.select(0, 2)
self.assertTrue(self.gdir.degree(vs, mode=ALL) == [4, 3])
self.assertTrue(self.gdir.degree(self.gdir.vs[1], mode=ALL) == 4)
def testMaxDegree(self):
self.assertTrue(self.gfull.maxdegree() == 9)
self.assertTrue(self.gempty.maxdegree() == 0)
self.assertTrue(self.g.maxdegree() == 3)
self.assertTrue(self.g.maxdegree(loops=True) == 5)
self.assertTrue(self.g.maxdegree([1, 2], loops=True) == 3)
self.assertTrue(self.gdir.maxdegree(mode=IN) == 2)
self.assertTrue(self.gdir.maxdegree(mode=OUT) == 3)
self.assertTrue(self.gdir.maxdegree(mode=ALL) == 4)
def testStrength(self):
# Turn off warnings about calling strength without weights
import warnings
warnings.filterwarnings("ignore",
"No edge weights for strength calculation",
RuntimeWarning)
# No weights
self.assertTrue(self.gfull.strength() == [9] * 10)
self.assertTrue(self.gempty.strength() == [0] * 10)
self.assertTrue(self.g.degree(loops=False) == [3, 3, 2, 2])
self.assertTrue(self.g.degree() == [5, 3, 2, 2])
# With weights
ws = [1, 2, 3, 4, 5, 6]
self.assertTrue(
self.g.strength(weights=ws, loops=False) == [7, 9, 5, 9])
self.assertTrue(self.g.strength(weights=ws) == [19, 9, 5, 9])
ws = [1, 2, 3, 4, 5, 6, 7]
self.assertTrue(
self.gdir.strength(mode=IN, weights=ws) == [7, 5, 5, 11])
self.assertTrue(
self.gdir.strength(mode=OUT, weights=ws) == [8, 9, 4, 7])
self.assertTrue(
self.gdir.strength(mode=ALL, weights=ws) == [15, 14, 9, 18])
vs = self.gdir.vs.select(0, 2)
self.assertTrue(
self.gdir.strength(vs, mode=ALL, weights=ws) == [15, 9])
self.assertTrue(
self.gdir.strength(self.gdir.vs[1], mode=ALL, weights=ws) == 14)
min_incident_edge = min(
incident_edges,
key=lambda edge: edge['weight']) # ребро з найменшою вагою
out_graph.add_edge(
source=min_incident_edge.source, # додати ребро у новий граф
target=min_incident_edge.target,
weight=min_incident_edge['weight'])
next_vertex = min_incident_edge.target \
if min_incident_edge.target != current_vertex \
else min_incident_edge.source # наступна вершина - один з кінців ребра
done.append(current_vertex) # відмітити пройдену вершину
prim(in_graph, out_graph, next_vertex,
done) # рекурсивно дивись в наступну вершину
source = Graph.Full(
vertex_count) # створює зв’язаний граф з вказаною кількістю вершин
for es in source.es:
es['weight'] = random.randint(1, 9)
min_ost = Graph(vertex_count)
prim(source, min_ost)
Thread(target=lambda: draw(source)).start()
Thread(target=lambda: draw(min_ost)).start()
return train_list, test_list
def generate_negative_samples(graph, number):
"""Generates negative samples for links, i.e. links that do not exist
:param graph: graph
:type graph: igraph.Graph
:param number: number of negative samples
:type number: int
:return: list of negative
"""
random.seed(350)
nodes = set(graph.vs.indices)
result = []
while number > 0:
v1 = random.sample(nodes, 1)[0]
not_neighbors = nodes.difference(graph.neighbors(v1)).difference({v1})
v2 = random.sample(not_neighbors, 1)[0]
if [v1, v2] in result or [v2, v1] in result:
continue
result.append([v1, v2])
number -= 1
return result
if __name__ == '__main__':
g = Graph.Full(3)
print(list(map(len, split_data(g.es, 0.2))))
def setUp(self):
self.graph = Graph.Full(10)
self.graph.vs["string"] = list("aaabbcccab")
self.graph.vs["int"] = [17, 41, 23, 25, 64, 33, 3, 24, 47, 15]
