def as_AM(self):
matrix = AM.Graph(self.vertices, self.weighted, self.directed)
for i in self.el:
matrix.insert_edge(i.source, i.dest, i.weight)
return matrix
def as_AM(self):
g = am.Graph(len(self.al), self.weighted, self.directed)
for i in range(len(self.al)):
for j in range(len(self.al[i])):
g.insert_edge(i, self.al[i][j].dest, self.al[i][j].weight)
print(g.representation)
return g
def as_AM(self):
matrix = AM.Graph(
len(self.al), self.weighted,
self.directed) # makes a AM graph that is same size as AL graph
for i in range(len(self.al)):
for j in self.al[i]:
matrix.insert_edge(i, j.dest, j.weight) # inserts edges
return matrix
def build_graphAM():
g_am = AM.Graph(4039)
f = open('facebook_combined.txt', 'r')
for line in f: # Iterates until there is no line left to read
v = line.split(' ') # Array of size 2 containing source and dest
g_am.insert_edge(int(v[0]), int(v[1]))
f.close()
return g_am
def al_to_am(g_al):
g_am = graphAM.Graph(len(g_al.al),
directed=g_al.directed,
weighted=g_al.weighted)
for v in range(len(g_al.al)):
for e in g_al.al[v]:
g_am.insert_edge(v, e.dest, e.weight)
return g_am
def as_AM(self):
matrix = AM.Graph(len(self.al), self.weighted, self.directed)
for i in range(len(self.al)):
for j in self.al[i]:
matrix.insert_edge(i, j.dest, j.weight)
return matrix
def as_AM(self):
#constructor for AM
g = gam.Graph(self.vertices,
weighted=self.weighted,
directed=self.directed)
for edge in self.el: #iterate through edges list
g.insert_edge(edge.source, edge.dest,
edge.weight) #insert corresponding values
return g
def as_AM(self):
# create an empty graph with the same length as current graph
matrix = AM.Graph(self.vertices, self.weighted, self.directed)
# insert edges using a loop
for i in self.el:
matrix.insert_edge(i.source, i.dest, i.weight)
return matrix
def as_AM(self):
matrix = AM.Graph(len(self.al))
for i in range(len(self.al)):
for edge in self.al[i]:
matrix.insert_edge(i, edge.dest)
return matrix
def as_AM(self):
g = graph_AM.Graph(len(self.al), weighted=self.weighted, directed=self.directed)
for i in range(len(self.al)):
for edge in self.al[i]:
if not self.directed:
if i < edge.dest:
g.insert_edge(i, edge.dest, edge.weight)
else:
g.insert_edge(i, edge.dest, edge.weight)
return g
def as_AM(self):
# create an empty graph with the same length as current graph
matrix = AM.Graph(len(self.al), self.weighted, self.directed)
# insert edges using a nested loop
for i in range(len(self.al)):
for j in self.al[i]:
matrix.insert_edge(i, j.dest, j.weight)
return matrix
def as_AM(self):
#constructor for AM graph
g = gam.Graph(len(self.al),
weighted=self.weighted,
directed=self.directed)
for i in range(len(self.al)): #iterates through np array
for j in range(len(self.al[i])): #lists inside np array
g.insert_edge(
i, self.al[i][j].dest,
self.al[i][j].weight) #inserts corresponding values
return g
def as_AM(self):
g = graph_AM.Graph(self.vertices,
weighted=self.weighted,
directed=self.directed)
for i in range(self.vertices):
for j in self.el:
if j.source == i:
if not self.directed:
if i < j.dest:
g.insert_edge(i, j.dest, j.weight)
else:
g.insert_edge(i, j.dest, j.weight)
return g
def matrix(s):
f = open(s, 'r', encoding="utf8")
lines = f.readlines()
f.close()
f = open(s, 'r', encoding="utf8")
nums = f.read()
f.close()
size = get_size(nums, lines)
G = graphAM.Graph(size)
for i in lines:
nums = i.split()
G.insert_edge(int(nums[0]), int(nums[1]), 1)
return G
def as_AM(self):
"""
Convert an adjacency list representation of a graph to an adjacency
matrix by traversing through the original representation and calling
the insert_edge() function from the adjacency matrix class for each
Edge object in the adjacency list.
"""
AM = am_graph.Graph(len(self.al), weighted=self.weighted, directed=self.directed)
for i in range(len(self.al)):
for edge in self.al[i]:
source = i
dest = edge.dest
weight = edge.weight
AM.insert_edge(source, dest, weight)
return AM
def as_AM(self):
g = g_AM.Graph(self.vertices, self.weighted, self.directed)
for list in range(len(self.al)):
for edge in range(len(self.al[list])):
g.insert_edge(edge.source, edge.dest, edge.weight)
return g
print(internal(T.root))
print('================ Question 10 ===============')
S = [1, 2, 3, 4, 6, 7]
for i in range(15):
print(i, find_sum_pair(S, i))
print('================ Question 11 ===============')
print(remove_duplicates([4, 2, 7, 9, 7, 8, 1, 9, 2, 4]))
print(remove_duplicates([4, 2, 7, 9, 9, 2, 4]))
print(remove_duplicates([2, 2, 4, 4, 4, 2, 4, 4, 2]))
print(remove_duplicates([2302]))
print(remove_duplicates([]))
print('================ Question 12 ===============')
g8 = graph_AM.Graph(5)
g8.insert_edge(0, 1)
g8.insert_edge(1, 2)
g8.insert_edge(1, 3)
g8.insert_edge(0, 3)
g8.insert_edge(2, 3)
g8.insert_edge(3, 4)
g8.insert_edge(2, 4)
g8.display()
if draw_figs:
g8.draw()
for i in range(5):
for j in range(i + 1, 5):
for k in range(j + 1, 5):
print('(u,v,w) = ({},{},{}), clique = {}'.format(
return g
#Question 5
def out_degrees(G):
return list(np.sum(G.am > -1, axis=1))
#question 6
def in_degrees(G):
return list(np.sum(G.am > -1, axis=0))
if __name__ == "__main__":
plt.close("all")
g_uduw = graph.Graph(5)
g_uduw.insert_edge(0, 1)
g_uduw.insert_edge(0, 2)
g_uduw.insert_edge(1, 2)
g_uduw.insert_edge(2, 3)
g_uduw.insert_edge(3, 4)
g_uduw.insert_edge(4, 1)
g_uduw.display()
g_uduw.draw()
g_duw = graph.Graph(5, directed=True)
g_duw.insert_edge(0, 1)
g_duw.insert_edge(0, 2)
g_duw.insert_edge(1, 2)
g_duw.insert_edge(2, 3)
g_duw.insert_edge(3, 4)
Ismael Villalobos
11-17-19
Lab Assignment 6
Professor Fuentes
TA-Dita Nath
Purpose:
'''
import matplotlib.pyplot as plt
import numpy as np
#import graph_AL as graph
import graph_AM as graph # Replace line 3 by this one to demonstrate adjacy maxtrix implementation
#import graph_EL as graph # Replace line 3 by this one to demonstrate edge list implementation
if __name__ == "__main__":
plt.close("all")
g = graph.Graph(6)
g.insert_edge(0, 1)
g.insert_edge(0, 2)
g.insert_edge(1, 2)
g.insert_edge(2, 3)
g.insert_edge(3, 4)
g.insert_edge(4, 1)
g.display()
g.draw()
g.delete_edge(1, 2)
g.display()
g.draw()
g = graph.Graph(6, directed=True)
g.insert_edge(0, 1)
g.insert_edge(0, 2)
def circle_graph(n):
g = graph.Graph(n, directed=True)
g.am[np.arange(n), (np.arange(n) + 1) % n] = 1
return g
def as_AM(self):
g = am.Graph(len(self.al),self.weighted,self.directed)
for i in self.al:
for j in i:
g.insert_edge(j.source,j.dest)
return g
def as_AM(self):
temp = gAM.Graph(len(self.al), directed=False)
for x in range(len(self.al)):
for y in range(len(self.al[x])):
temp.insert_edge(x, self.al[x][y].dest)
return temp
def as_AM(self):
g = am.Graph(self.vertices, self.weighted, self.directed)
for e in self.el:
g.insert_edge(e.source, e.dest, e.weight)
return g
def as_AM(self):
temp = gAM.Graph(self.vert, directed=False)
for x in range(len(self.el)):
temp.insert_edge(self.el[x].source, self.el[x].dest)
return temp
import matplotlib.pyplot as plt
import graph_AM as graph
if __name__ == "__main__":
plt.close("all")
g = graph.Graph(16)
g.insert_edge(0, 10)
g.insert_edge(10, 2)
g.insert_edge(2, 14)
g.insert_edge(2, 11)
g.insert_edge(14, 4)
g.insert_edge(11, 1)
g.insert_edge(4, 13)
g.insert_edge(1, 13)
g.insert_edge(13, 5)
g.insert_edge(5, 15)
g.display()
# g.draw()
print("Breadth-first search:")
print(g.bfs(0, 15))
print("Depth-first search:")
print(g.dfs(0, 15))
p = g.DFS()
end = time.time()
print('To solve the puzzle, you must first travel from world state ', end = '')
for state in range(len(p)-1):
print(p[state], ' to ', end = ' ')
print(p[-1])
print('Runtime for DFS: ', end-start)
print()
#Solving Puzzle using Adjacency Matrix Representation; we first create the graph and insert
#legal transition edges into the graph, connecting only legal states with legal
#transitions.
print('Adjacency Matrix Representation of Graph')
print()
g = g_AM.Graph(16)
g.insert_edge(0, 5, 1)
g.insert_edge(2, 7, 1)
g.insert_edge(2, 11, 1)
g.insert_edge(4, 13, 1)
g.insert_edge(4, 7, 1)
g.insert_edge(4, 5, 1)
g.insert_edge(8, 13, 1)
g.insert_edge(8, 11, 1)
g.insert_edge(10, 15, 1)
g.insert_edge(10, 11, 1)
g.draw()
g.display()
start = time.time()
p = g.BFS()
end = time.time()
#fox, chicken, grain, person
#invalid: [1,1,0,0](12) and [0,0,1,1](3)
# [0,1,1,0](6) and [1,0,0,1](9)
# [0,0,0,1](1) and [1,1,1,0] (14)
valid = validV() #valid inputs
bfirst = {"1","3","5"} #options for breadth first
dfirst = {"2","4","6"} #options for depth first
if (option in bfirst or option in dfirst):
if (option in bfirst):
if (option=="1"): #AL Breadth-first
print("======READING AL BREADTH-FIRST======")
g = gal.Graph(16)
elif (option=="3"): #AM Breadth-first
print("======READING AM BREADTH-FIRST======")
g = gam.Graph(16)
else: #EL Breadth-first
print("======READING EL BREADTH-FIRST======")
g = gel.Graph(16)
start = time.time()
fillGraph(g, valid) #call to fill graph that was chosen
timeGraph = time.time()-start
g.display() #show graph
start = time.time()
path = g.breadth_search() #call to search
timePath = time.time()-start
else:
if (option=="2"): #AL Depth-first
print("======READING AL DEPTH-FIRST======")
g = gal.Graph(16)
#3 [1, 2]
#4 [1, 3]
#5 [2, 3]
#6 [2, 4]
#7 [3, 4]
#8 [2, 6]
#9 [3, 6]
#10 [4, 6]
#11 [4, 7]
#12 None
#13 [6, 7]
#14 None
print('================ Question 8 ===============')
g8 = graph_AM.Graph(5,directed=True)
g8.insert_edge(0,1)
g8.insert_edge(1,2)
g8.insert_edge(1,3)
g8.insert_edge(0,3)
g8.insert_edge(2,3)
g8.insert_edge(3,4)
g8.insert_edge(2,4)
g8.display()
g8.draw('Hey 1')
make_undirected(g8)
g8.display()
g8.draw('Hey 2')
#Graph representation
#directed: False, weighted: False
print('\n1. Test Graphs')
print('2. Puzzle')
choice2=int(input('Select choice: '))
if choice2==1:
test.tests(choice)
if choice2==2:
if choice==1:
g=AL.Graph(16)
if choice==2:
g=AM.Graph(16)
if choice==3:
g=EL.Graph(16)
g.insert_edge(0,5)
g.insert_edge(5,4)
g.insert_edge(4,7)
g.insert_edge(4,13)
g.insert_edge(2,13)
g.insert_edge(7,11)
g.insert_edge(10,11)
g.insert_edge(10,15)
timer=0
print('\n1. Breadth First Search')
print('\n *********** Question 2 **************')
g = graph_EL.Graph(5, weighted=True, directed=True)
g.insert_edge(0, 1, 4)
g.insert_edge(0, 2, 7)
g.insert_edge(1, 2, 2)
g.insert_edge(2, 3, 1)
g.insert_edge(2, 4, 8)
g.insert_edge(3, 4, 5)
g.insert_edge(4, 1, 4)
g.display()
g.draw()
print(in_degrees(g))
print('\n *********** Question 3 **************')
g = graph_AM.Graph(5, weighted=True, directed=True)
g.insert_edge(0, 1, 4)
g.insert_edge(0, 2, 7)
g.insert_edge(1, 2, 2)
g.insert_edge(2, 3, 1)
g.insert_edge(2, 4, 8)
g.insert_edge(3, 4, 5)
g.insert_edge(4, 1, 4)
g.display()
g.draw()
prev = [-1, 0, 1, 2, 2]
for v in range(5):
print('dist to {} = {}'.format(v, dist_from_prev(g, prev, v)))
print('\n *********** Question 4 **************')
g = graph_AL.Graph(6, weighted=True)
