def mk_testgraphs():
"""erstellt zwei Testgraphen und vergleicht sie"""
g1 = dsa.Graph()
g2 = dsa.Graph()
g1.make_node("n1")
g1.make_node("n2")
g1.make_node("n3")
g1.make_node("n4")
g1.make_node("n5")
g1.make_node("n6")
g1.make_node("n7")
g1.make_edge("n1", "n2")
g1.make_edge("n2", "n3")
g1.make_edge("n3", "n4")
g1.make_edge("n1", "n4")
g1.make_edge("n6", "n5")
g1.make_edge("n5", "n7")
g1.make_edge("n6", "n7")
g1.make_edge("n1", "n7")
g2.make_node("n1")
g2.make_node("n2")
g2.make_node("n3")
g2.make_node("n4")
g2.make_node("n5")
g2.make_node("n6")
g2.make_node("n7")
g2.make_edge("n1", "n2")
g2.make_edge("n2", "n3")
g2.make_edge("n3", "n4")
g2.make_edge("n1", "n4")
g2.make_edge("n6", "n5")
g2.make_edge("n5", "n7")
g2.make_edge("n6", "n7")
g2.make_edge("n6", "n1")
return compare(g1, g2)
def Liniengraph(graph):
Liniengraph = dsa.Graph()
for edge in graph.edges:
Liniengraph.make_node(
str(graph.edge_to_vertices(edge)[0]) +
str(graph.edge_to_vertices(edge)[1]))
for edge in graph.edges:
Nodes = [
str(graph.edge_to_vertices(edge)[0]),
str(graph.edge_to_vertices(edge)[1])
]
for edge2 in graph.edges:
if edge == edge2:
continue
Nodes2 = [
str(graph.edge_to_vertices(edge2)[0]),
str(graph.edge_to_vertices(edge2)[1])
]
#Auf Übereinstimmung prüfen
if Nodes[0] == Nodes2[0] or Nodes[0] == Nodes2[1] or Nodes[
1] == Nodes2[0] or Nodes[1] == Nodes2[1]:
if not Liniengraph.get_edge(
str(graph.edge_to_vertices(edge)[0]) +
str(graph.edge_to_vertices(edge)[1]),
str(graph.edge_to_vertices(edge2)[0]) +
str(graph.edge_to_vertices(edge2)[1])):
Liniengraph.make_edge(
str(graph.edge_to_vertices(edge)[0]) +
str(graph.edge_to_vertices(edge)[1]),
str(graph.edge_to_vertices(edge2)[0]) +
str(graph.edge_to_vertices(edge2)[1]))
return Liniengraph
def mk_graph(c, safe=False):
g = dsa.Graph()
for i in range(5):
g.make_node("n{}".format(i))
for i in range(5):
g.make_edge(g.nodes["n{}".format(i)], g.nodes["n{}".format(
(i + 1) % 5)])
c_f = True
nn = 5
while c_f:
addnode(g, 0.75)
print("graph:", g)
c_f = faerbbar(g, c)[0]
print("Anzahl der knoten", nn)
nn += 1
sure = faerbbar2(g, c)[0]
if safe:
while not sure:
addnode(g, 0.75)
print("graph", g)
sure = faerbbar2(g, c)[0]
print("anzahl der knoten", nn)
nn += 1
#colordict=faerbbar(g,c)[1]
#save_graph(g,c,colordict)
return g
def connect(graphs):
"""connect all graphs in the list "graphs" as described by Vincent
and add the new nodes"""
#print("connect wird mit folgender Liste aufgerufen:",graphs)
c = len(graphs)
G_c = dsa.Graph() #create a new graph
# Calculates the number of new nodes
cFaculty = fak(c)
#print("cFaculty",cFaculty)
for i in range(1,cFaculty+1): # Creates the new nodes
G_c.make_node( "G_" + str(c) + ";" + str(c +1 ) + ";" + str(i))
# "G_C;number of the colour; number of the node;"
#print("G_c nach einfügen neuer Knoten:", G_c)
#copy nodes and edges from "graphs" in "G_c"
for graph in graphs:
#print("Mit diesem Graph fängt er an:",graph)
for node_name in graph.nodes:
new_name = "G_" + str(c) + node_name # Writes G_c in front of the name
G_c.make_node(new_name) # Makes the new node2
#print("G_c nach einfügen eines weiteren Knoten:",G_c)
# Writes all edges from graph to g_c # This part dosen't work, it only copys a few edges
for edge in graph.edges:
edgelist2=[]
edgelist=graph.edge_to_vertices(edge)
for node in edgelist:
edgelist2.append("G_{}{}".format(c,node))
#print("edgelist1:",edgelist)
#print("edgelist2:",edgelist2)
f=True
if f:
G_c.make_edge(edgelist2[0],edgelist2[1])
for node_name in graph.nodes:
#print("G_c nach einfügen von Kanten von diesen Knoten aus zu alten Knoten:", G_c)
# makes edges beween the node and the new nodes
c_node = get_c(node_name)
# Adds new edges to a difficult to explain principle
colour_node = get_colour(node_name)
#print("colour_node({})".format(node_name), colour_node)
colour_node = colour_node - 1
c_node_Faculty = fak(c_node)
length_of_a_part = cFaculty / c_node_Faculty
i = 1
while i < cFaculty + 1:
if c_node!=0:
#print("(i/length_of_a_part) % c_node :", (i/length_of_a_part) % c_node )
if int(i/length_of_a_part) % c_node == colour_node:
if not G_c.get_edge(new_name, "G_" + str(c) + ";" + str(c +1 ) + ";" + str(i)):
G_c.make_edge(new_name, "G_" + str(c) + ";" + str(c +1 ) + ";" + str(i))
else:
# The node of the G_0 needs a edge to every new node
G_c.make_edge(new_name, "G_" + str(c) + ";" + str(c +1 ) + ";" + str(i))
i = i + 1
#print("connect gibt folgenden Graph aus:", G_c)
return G_c
def fullyconnect(n):
graph = dsa.Graph()
for i in range(n):
graph.make_node("n{}".format(i + 1))
for node in graph.nodes:
for node1 in graph.nodes:
if str(node) != str(node1):
if not graph.get_edge(node, node1):
graph.make_edge(node, node1)
return graph
def Kreis(AnzahlNodes):
if AnzahlNodes < 3:
AnzahlNodes = 3
Graph = dsa.Graph()
Graph.make_node(str(0))
for i in range(1, AnzahlNodes):
Graph.make_node(str(i))
Graph.make_edge(str(i), str(i - 1))
#print(hamiltonisch(Graph))
Graph.make_edge(str(0), str(AnzahlNodes - 1))
return Graph
def connect(graphs):
"""connect all graphs in the list "graphs" as described by Vincent
and add the new nodes"""
print("connect wird mit folgender Liste aufgerufen:", graphs)
c = len(graphs)
G_c = dsa.Graph() #create a new graph
# Calculates the number of new nodes
cFaculty = fak(c)
for i in range(1, cFaculty + 1): # Creates the new nodes
colour = cFaculty * fak(i)
G_c.make_node(
"G_" + str(c) + ";" + str(c + 1) + ";" +
str(i)) # "G_C;number of the colour; number of the node;"
#copy nodes and edges from "graphs" in "G_c"
for graph in graphs:
for node_name in graph.nodes:
new_name = "G_" + str(
c) + node_name # Writes G_c in front of the name
G_c.make_node(new_name) # Makes the new node
# Writes all edges from graph to g_c
neighbours1 = neighbours(
graph, node_name) # Creates a list of neighbours in the graph
for neighbour_node in neighbours1: # If there is not already an edge in G_c a new edge is created
neighbours_new_name = "G_" + str(c) + str(
node_name) # Writs G_c in front of the name
if not graph.is_edge(new_name, neighbours_new_name):
if new_name != neighbours_new_name:
graph.make_edge(new_name, neighbours_new_name)
# makes edges beween the node and the new nodes
c_node = get_c(node_name)
#colour_node ?? = get_colour(node_name) # Adds new edges to a difficult to explain principle
colour = get_colour(node_name)
colour = colour - 1
c_node_Faculty = fak(c_node)
length_of_a_part = cFaculty / c_node_Faculty
i = 1
while i < cFaculty + 1:
if c_node != 0:
if (i / length_of_a_part) % c_node == colour:
G_c.make_edge(
new_name,
"G_" + str(c) + ";" + str(c + 1) + ";" + str(i))
#G_c.make_edge(new_name, "G_" + str(c) + ";" + str(c +1 ) + ";" + str(i))
i += 1
return G_c
def nlist2graph(nlist, graph):
"""nlist ist eine Liste aus Knoten, die auch in graph vorkommen.
Die Funktion erstellt nun alle Kanten, die es in graph gibt
und die zwischen den Knoten in nlist existieren"""
TG = dsa.Graph()
for node1 in nlist:
TG.make_node(node1)
for node1 in TG.nodes:
for node2 in TG.nodes:
if str(node1) != str(node2):
if graph.get_edge(node1, node2):
if not TG.get_edge(node1, node2):
TG.make_edge(node1, node2)
return TG
def change_node_names(graph, c, colordict):
"""changes names of the nodes and edges in "graph"
so that they suit the "dsa_aufgabe9.py" code"""
G_c = dsa.Graph()
for node in graph.nodes:
new_name = change_node_name(node, c, colordict)
G_c.make_node(new_name)
for edge in graph.edges:
edgelist = graph.edge_to_vertices(edge)
edgelist2 = []
for node in edgelist:
edgelist2.append(change_node_name(node, c, colordict))
G_c.make_edge(edgelist2[0], edgelist2[1])
return G_c
def Liniengraph(graph):
Liniengraph = dsa.Graph()
for edge in graph.edges:
Liniengraph.make_node(str(edge))
#print(Liniengraph)
for edge in graph.edges:
Nodes = graph.edge_to_vertices(edge)
for edge2 in graph.edges:
if edge == edge2:
continue
Nodes2 = graph.edge_to_vertices(edge2)
#Auf Übereinstimmung prüfen
if Nodes[0] == Nodes2[0] or Nodes[0] == Nodes2[1] or Nodes[
1] == Nodes2[0] or Nodes[1] == Nodes2[1]:
#print(edge)
#print(edge2)
if not Liniengraph.get_edge(str(edge), str(edge2)):
Liniengraph.make_edge(str(edge), str(edge2))
return Liniengraph
#print("getesteter Knoten:",node,", nachbarknoten:",dsa.neighbors(graph,node),", waynodes:",waynodes)
waynodes.append(node)
if len(waynodes) == len(graph.nodes):
if graph.get_edge(waynodes[-1], waynodes[0]):
print("hamiltonweg:", waynodes)
return True
if len(waynodes) < len(graph.nodes):
if hamiltonisch(graph, node, waynodes, lenght):
return True
else:
waynodes.remove(node)
else:
break
#print("forschleife ist durch")
return False
graph = dsa.Graph()
graph.make_node("a")
graph.make_node("b")
graph.make_node("c")
graph.make_node("d")
graph.make_edge("a", "b")
graph.make_edge("b", "c")
graph.make_edge("c", "d")
graph.make_edge("d", "a")
graph.make_edge("a", "c")
lg = Liniengraph(graph)
graphtopdf.plotgraph(lg, "5_graph", quelltext=True)
import dsa
g = dsa.Graph()
a = g.make_node("a")
b = g.make_node("b")
e = g.make_edge("a", "b")
h = dsa.Graph()
nodelist = []
edgelist = []
for i in range(5):
nodelist.append(h.make_node("n{}".format(i)))
counter = 0
for n in nodelist:
if counter != i:
edgelist.append(h.make_edge("n{}".format(i), n))
counter += 1
if __name__ == "__main__":
print(g)
print(h)
print(neighbours(h, "n0"))
# -*- coding: utf-8 -*-
"""
Created on Mon Jul 2 16:18:01 2018
@author: DELL
"""
import dsa
import shelve
gs = shelve.open("dsa_A9_graphs", writeback=True)
if "0" not in gs:
g = dsa.Graph()
g.make_node("G_0;1;1")
#g.make_node("G_1;2;1")
gs["0"] = g
gs.close()
def save(graph, c):
"""save "graph" g_c with index "c" to "dsa_A9_graphs" """
gs = shelve.open("dsa_A9_graphs")
if str(c) in gs.keys():
g_c = gs[str(c)]
if len(g_c.nodes) > len(graph.nodes):
gs[str(c)] = graph
else:
gs[str(c)] = graph
gs.close()
