def run(self):
while self.heap.size > 0:
min = self.heap.removeMin()
# checks if the vertices of the removed edge have already been put into the tree
try1 = [x for x in self.verticesInTree if x.id is min.v1.id]
try2 = [x for x in self.verticesInTree if x.id is min.v2.id]
v1 = Vertex(min.v1.id) if len(try1) is 0 else try1[0]
v2 = Vertex(min.v2.id) if len(try2) is 0 else try2[0]
edge = Edge(v1, v2, min.weight)
edge2 = Edge(v2, v1, min.weight)
# check to see if the two vertices are connected in the graph
# if they are, then we do not add this edge
if self.verticesAreConnected(v1, v2) and self.nodes[v1.id] < 2 and self.nodes[v2.id] < 2:
self.edgesInTree.append(edge)
self.edgesInTree.append(edge2)
v1.addEdgeFrom(edge)
v1.addEdgeTo(edge2)
v2.addEdgeFrom(edge2)
v2.addEdgeTo(edge)
if len(try1) is 0:
self.verticesInTree.append(v1)
if len(try2) is 0:
self.verticesInTree.append(v2)
self.nodes[v1.id] += 1
self.nodes[v2.id] += 1
return self.edgesInTree
def test_contract(self):
test_case = Graph()
test_node1 = Node(node_id=1)
test_node2 = Node(node_id=2)
test_node3 = Node(node_id=3)
test_edge_1_3 = Edge(test_node1,test_node3)
test_edge_1_2 = Edge(test_node1,test_node2)
test_edge_2_3 = Edge(test_node2,test_node3)
test_case.add_node(test_node1)
test_case.add_node(test_node2)
test_case.add_node(test_node3)
test_case.add_undirected_edges([test_edge_1_3,test_edge_1_2,test_edge_2_3])
result_node = test_case.contract(test_edge_1_2)
test_result_node_edges = test_case.get_node_edges(result_node)
test_node3_edges = test_case.get_node_edges(test_node3)
self.assertTrue(len(test_result_node_edges) == 2)
self.assertTrue(len(test_node3_edges) == 2)
self.assertTrue(len(result_node.nodes_contracted) ==2)
def construct_graph(image, image_seed):
graph = construct_nodes(image, image_seed)
mean, variance = stats(graph)
gauss = multivariate_normal(mean=mean, cov=variance)
fg_node = Node((-1, -1), None, "fg")
bg_node = Node((-2, -2), None, "bg")
for pos, node in graph.iteritems():
adj_position = [(x[0] + y[0], x[1] + y[1])
for x, y in zip(constants.MOVES, [pos] * 4)]
neighbors = [graph[x] for x in adj_position if x in graph]
fg_weight = calc_fg_weight(node, gauss)
bg_weight = calc_bg_weight(node, gauss)
fg_edge = Edge(node, fg_node, fg_weight)
bg_edge = Edge(node, bg_node, bg_weight)
edges = [Edge(node, x, calc_weight(node, x)) for x in neighbors]
graph[fg_node.coord] = fg_node
graph[bg_node.coord] = bg_node
return graph, fg_node, bg_node
def test_reassign_edge(self):
test_case = Graph()
test_node1 = Node(node_id=1)
test_node2 = Node(node_id=2)
test_node3 = Node(node_id=3)
test_edge_1_3 = Edge(test_node1,test_node3)
test_edge_2_3 = Edge(test_node2,test_node3)
test_case.add_node(test_node1)
test_case.add_node(test_node2)
test_case.add_node(test_node3)
test_case.add_undirected_edge(test_edge_1_3)
test_case.add_undirected_edge(test_edge_2_3)
test_super_node = Node()
test_case.add_node(test_super_node)
test_case.reassign_edges([test_node1,test_node2],test_super_node)
test_super_node_edges = test_case.get_node_edges(test_super_node)
test_node1_edges = test_case.get_node_edges(test_node1)
test_node2_edges = test_case.get_node_edges(test_node2)
test_node3_edges = test_case.get_node_edges(test_node3)
self.assertTrue(len(test_super_node_edges) == 2)
self.assertTrue(len(test_node1_edges) == 0)
self.assertTrue(len(test_node2_edges) == 0)
self.assertTrue(len(test_node3_edges) == 2)
def select(self):
self._selected = True
self._photoviewer.add_selected_polygon(self)
first_node = Node(self)
first_node.setPos(self.polygon_points[0] + self.pos())
self._nodes = [first_node]
self._edges = []
self._scene.addItem(first_node)
for idx in range(1, len(self.polygon_points)):
new_node = Node(self)
new_node.setPos(self.polygon_points[idx] + self.pos())
self._scene.addItem(new_node)
new_edge = Edge(self._nodes[idx - 1], new_node, self)
self._scene.addItem(new_edge)
self._nodes.append(new_node)
self._edges.append(new_edge)
# connect last edge to first
new_edge = Edge(self._nodes[len(self._nodes) - 1], self._nodes[0],
self)
self._scene.addItem(new_edge)
self._edges.append(new_edge)
def create_edges_from_navitia(response, graph):
journey = response['journeys'][0]
edges = []
# add edges
for section in journey["sections"]:
# like with nodes, we do not take care of waiting sections. Transfer sections are treated after
if section['type'] != "waiting" and section['type'] != "transfer":
src = calculate_node_coord_from_navitia(section['from'])
dest = calculate_node_coord_from_navitia(section['to'])
# we verify that both of the nodes are in the graph
if graph.find_node_from_coord(src.coord) and graph.find_node_from_coord(dest.coord):
# adding the edge to the node
edge = Edge(graph.find_node_from_coord(src.coord), graph.find_node_from_coord(dest.coord),
section['duration'], section['duration'])
set_edge_info(section, edge)
edges.append(edge)
# todo add else -> throw error
# if the section is of type transfer, we only verify that source and destination are different to add the edge to the graph
elif section['type'] == "transfer":
if section['from']['name'] != section['to']['name']:
src = calculate_node_coord_from_navitia(section['from'])
dest = calculate_node_coord_from_navitia(section['to'])
if graph.find_node_from_coord(src.coord) and graph.find_node_from_coord(dest.coord):
edge = Edge(graph.find_node_from_coord(src.coord), graph.find_node_from_coord(dest.coord),
section['duration'],
section['duration'])
set_edge_info(section, edge)
edges.append(edge)
return edges
def scan_triangle(self, min_y_vert, mid_y_vert, max_y_vert, handedness,
colour, fill):
"""Draw triangle scan lines"""
top_to_bottom = Edge(min_y_vert, max_y_vert)
top_to_middle = Edge(min_y_vert, mid_y_vert)
middle_to_bottom = Edge(mid_y_vert, max_y_vert)
left = top_to_bottom
right = top_to_middle
if handedness:
left, right = right, left
y_start = top_to_middle.y_start
y_end = top_to_middle.y_end
for j in xrange(y_start, y_end):
self.draw_scan_line(left, right, j, colour, fill)
left.step()
right.step()
left = top_to_bottom
right = middle_to_bottom
if handedness:
left, right = right, left
y_start = middle_to_bottom.y_start
y_end = middle_to_bottom.y_end
for j in xrange(y_start, y_end):
self.draw_scan_line(left, right, j, colour, fill)
left.step()
right.step()
def test_good_constructor_args(self):
route = Route("AB1", Edge(i='B', f='C', d=1), Edge(i='C', f='D', d=2),
Edge(i='D', f='A', d=3))
with self.assertRaises(AttributeError):
_ = route.magnitude
_ = route.stops
self.assertEqual(route.end_vertex, 'A')
def find_nodes_and_edges(self):
''' Taking all of the paths/roads in the given area, this breaks up those paths/roads into edges and stores in a list.'''
self.edge_list = []
for way in self.ways:
breakpoints = []
for i in range(len(way.nodes)):
if way.nodes[i] in self.intersections:
breakpoints.append(i)
if breakpoints == []:
new_edge = Edge()
new_edge.set_start_node(way.nodes[0])
new_edge.set_end_node(way.nodes[-1])
if len(way.nodes) > 2:
new_edge.add_multiple_nodes(way.nodes[1:-1])
new_edge.update_distance()
self.edge_list.append(new_edge)
else:
new_ways = []
for point in range(len(breakpoints) - 1):
new_ways.append(
way.nodes[breakpoints[point]:breakpoints[point + 1] +
1])
for edge_way in new_ways:
new_edge = Edge()
new_edge.set_start_node(edge_way[0])
new_edge.set_end_node(edge_way[-1])
if len(edge_way) > 2:
new_edge.add_multiple_nodes(edge_way[1:-1])
new_edge.update_distance()
self.edge_list.append(new_edge)
def init_grid(self):
self.node_grid = []
node = None
for y in range(self.node_height):
self.node_grid.append([])
for x in range(self.node_width):
node = Node(
str(x) + " " + str(y), [], (x - 1) * Node.node_size // 2,
(y) * Node.node_height, x % 2 == y % 2)
self.node_grid[y].append(node)
Node.node_list.append(node)
# Create connections
grid = self.node_grid
for i in range(len(grid)):
for j in range(len(grid[i])):
if j != len(grid[i]) - 1:
grid[i][j].connections.append(
Edge(grid[i][j], grid[i][j + 1]))
if j != 0:
grid[i][j].connections.append(
Edge(grid[i][j], grid[i][j - 1]))
if grid[i][j].flipped and i > 0:
grid[i][j].connections.append(
Edge(grid[i][j], grid[i - 1][j]))
if not grid[i][j].flipped and i < len(grid) - 1:
grid[i][j].connections.append(
Edge(grid[i][j], grid[i + 1][j]))
Edge.edge_list.extend(grid[i][j].connections)
def test_topological_sort(self):
graph = Graph()
test_nodes = [
Node(node_id=0),
Node(node_id=1),
Node(node_id=2),
Node(node_id=3)
]
graph.add_nodes(test_nodes)
graph.add_direct_edge(test_nodes[0], Edge(test_nodes[0],
test_nodes[1]))
graph.add_direct_edge(test_nodes[0], Edge(test_nodes[0],
test_nodes[2]))
graph.add_direct_edge(test_nodes[1], Edge(test_nodes[1],
test_nodes[3]))
graph.add_direct_edge(test_nodes[2], Edge(test_nodes[2],
test_nodes[3]))
topological_sort(graph)
self.assertEqual(1, test_nodes[0].get_distance())
self.assertEqual(4, test_nodes[3].get_distance())
self.assertTrue(test_nodes[2].get_distance() == 2
or test_nodes[2].get_distance() == 3)
self.assertTrue(test_nodes[1].get_distance() == 2
or test_nodes[1].get_distance() == 3)
def parse(self, words: 'list[str]'):
self.initParse(len(words))
for k, word in enumerate(words + ['END']):
#print(word)
it = 0
while it < len(self.edges[k]):
e = self.edges[k][it]
dot_idx = e.deps.index('*')
if dot_idx+1 < len(e.deps):
# no more tokens, should only complete
if k == len(words):
it+= 1
continue
token = e.deps[dot_idx+1]
if isNonterminal(token):
for prod in self.prods[token]:
self.addEdge(k, Edge(token, ['*']+prod, k, Ast(token, prod)))
else:
if token == word and token in [ts[0] for ts in self.prods[e.head]]:
self.addEdge(k+1, Edge(e.head, [token, '*'], e.start, Ast(e.head, [token])))
else:
for oe in self.edges[e.start]:
if oe.getAfterDot() == e.head:
newDeps = [d for d in oe.deps]
idx = newDeps.index('*')
newDeps[idx] = newDeps[idx+1]
newDeps[idx+1] = '*'
ne = Edge(oe.head, newDeps, oe.start, oe.ast.replaceLeaf(idx, e.ast))
self.addEdge(k, ne)
if ne.start == 0 and k == len(words):
yield ne.ast
it+=1
def __create_edges(self):
if self.__indexes is None:
return None
dist = set()
dup = set()
for i in range(0, len(self.indexes), 3):
a = Edge(self.indexes[i + 0], self.indexes[i + 1])
b = Edge(self.indexes[i + 1], self.indexes[i + 2])
c = Edge(self.indexes[i + 2], self.indexes[i + 0])
if a in dist:
dup.add(a)
else:
dist.add(a)
if b in dist:
dup.add(b)
else:
dist.add(b)
if c in dist:
dup.add(c)
else:
dist.add(c)
dist = dist.difference(dup)
dist = list(dist)
self.__edges = dist
def getInputChain(inputValues, uniqNameStr):
inputChain = Graph()
outNode = Node('{}_out'.format(uniqNameStr))
inputChain.addNode(outNode)
lastNode = outNode
for idx, val in enumerate(inputValues):
nameSuffix = '{}_t{}'.format(uniqNameStr, idx)
if val == 1:
newNode = Node('Inverter_{}'.format(nameSuffix))
inputChain.addNode(newNode)
inputChain.addEdge(Edge(newNode, lastNode))
lastNode = newNode
elif val != 0:
print(
'ERROR: buildInputChain - unkown value = {}. should be 0 or 1.'
.format(val))
exit()
if idx == len(inputValues) - 1: continue
newNode = Node('LatchIn_{}'.format(nameSuffix))
inputChain.addNode(newNode)
inputChain.addEdge(Edge(newNode, lastNode))
lastNode = newNode
inpNode = Node('chainInp_{}'.format(nameSuffix))
inputChain.addNode(inpNode)
inputChain.addEdge(Edge(inpNode, lastNode))
inputChain.defineOutput(outNode)
inputChain.defineInput(inpNode)
return inputChain
def scan_triangle(self, minYVert, midYVert, maxYVert, handedness):
edge_top_to_bottom = Edge(minYVert, maxYVert)
edge_top_to_middle = Edge(minYVert, midYVert)
edge_middle_to_bottom = Edge(midYVert, maxYVert)
self.scan_edges(edge_top_to_bottom, edge_top_to_middle, handedness)
self.scan_edges(edge_top_to_bottom, edge_middle_to_bottom, handedness)
def addEdge(self, orig, dest, w):
newEdge = Edge(orig, dest, w)
newTranspEdge = Edge(dest, orig, w)
newKey = orig.getName() + ' ' + dest.getName()
newTranspKey = dest.getName() + ' ' + orig.getName()
self.__E[newKey] = newEdge
self.__ET[newTranspKey] = newTranspEdge
def initialize_edges_niid(num_edges, clients, args, client_class_dis):
"""
This function is specially designed for partiion for 10*L users, 1-class per user, but the distribution among edges is iid,
10 clients per edge, each edge have 5 classes
:param num_edges: L
:param clients:
:param args:
:return:
"""
#only assign first (num_edges - 1), neglect the last 1, choose the left
edges = []
p_clients = [0.0] * num_edges
label_ranges = [[0,1,2,3,4],[1,2,3,4,5],[5,6,7,8,9],[6,7,8,9,0]]
for eid in range(num_edges):
if eid == num_edges - 1:
break
assigned_clients_idxes = []
label_range = label_ranges[eid]
for i in range(2):
for label in label_range:
# 5 labels in total
if len(client_class_dis[label]) > 0:
assigned_client_idx = np.random.choice(client_class_dis[label], 1, replace=False)
client_class_dis[label] = list(set(client_class_dis[label]) - set(assigned_client_idx))
else:
label_backup = 2
assigned_client_idx = np.random.choice(client_class_dis[label_backup],1, replace=False)
client_class_dis[label_backup] = list(set(client_class_dis[label_backup]) - set(assigned_client_idx))
for idx in assigned_client_idx:
assigned_clients_idxes.append(idx)
edges.append(Edge(id = eid,
cids=assigned_clients_idxes,
shared_layers=copy.deepcopy(clients[0].model.shared_layers)))
[edges[eid].client_register(clients[client]) for client in assigned_clients_idxes]
edges[eid].all_trainsample_num = sum(edges[eid].sample_registration.values())
p_clients[eid] = [sample / float(edges[eid].all_trainsample_num)
for sample in list(edges[eid].sample_registration.values())]
edges[eid].refresh_edgeserver()
#And the last one, eid == num_edges -1
#Find the last available labels
eid = num_edges - 1
assigned_clients_idxes = []
for label in range(10):
if not client_class_dis[label]:
print("label{} is empty".format(label))
else:
assigned_client_idx = client_class_dis[label]
for idx in assigned_client_idx:
assigned_clients_idxes.append(idx)
client_class_dis[label] = list(set(client_class_dis[label]) - set(assigned_client_idx))
edges.append(Edge(id=eid,
cids=assigned_clients_idxes,
shared_layers=copy.deepcopy(clients[0].model.shared_layers)))
[edges[eid].client_register(clients[client]) for client in assigned_clients_idxes]
edges[eid].all_trainsample_num = sum(edges[eid].sample_registration.values())
p_clients[eid] = [sample / float(edges[eid].all_trainsample_num)
for sample in list(edges[eid].sample_registration.values())]
edges[eid].refresh_edgeserver()
return edges, p_clients
def test_str(self):
self.spanning_tree.addEdge(Edge(0, 1))
self.spanning_tree.addEdge(Edge(1, 2))
self.spanning_tree.addEdge(Edge(1, 3))
expected = "(0, 1), (1, 2), (1, 3)"
actual = self.spanning_tree.__str__()
self.assertEqual(expected, actual)
def substitutes(self, data):
graph = nx.Graph()
for data_y in range(0, len(data)):
for data_x in range(0, len(data[data_y])):
orig_x = data_x
orig_y = data_y
ov_y = 0
ov_x = 0
matched = True
while True == matched and ov_y < len(self.__overlay):
if None != self.__overlay[ov_y][ov_x]:
if not re.match(str(self.__overlay[ov_y][ov_x]),
str(data[orig_y][orig_x]), re.UNICODE):
matched = False
if ov_x < len(self.__overlay[ov_y]) - 1:
ov_x = ov_x + 1
orig_x = orig_x + 1
if orig_x >= len(data[orig_y]):
matched = False
else:
ov_x = 0
orig_x = data_x
ov_y = ov_y + 1
orig_y = orig_y + 1
if orig_y >= len(data) and ov_y < len(self.__overlay):
matched = False
if True == matched:
for obj in self.__substitutes:
if isinstance(obj, Edge):
edge = obj
start = edge.start() + (data_x, data_y)
end = edge.end() + (data_x, data_y)
_above = None
_below = None
z_order = None
if edge.above() != None:
above_start = edge.above().start() + (data_x,
data_y)
above_end = edge.above().end() + (data_x,
data_y)
_above = Edge(above_start, above_end)
if edge.below() != None:
below_start = edge.below().start() + (data_x,
data_y)
below_end = edge.below().end() + (data_x,
data_y)
_below = Edge(below_start, below_end)
graph.add_node(start, options=self.__options)
graph.add_node(end, options=self.__options)
graph.add_edge(start,
end,
above=_above,
below=_below,
z_order=edge.z_order())
elif isinstance(obj, Node):
start = obj + (data_x, data_y)
graph.add_node(start, options=self.__options)
return graph
def addEdge(self, source, sink, capacity):
newEdge = Edge(source, sink, capacity)
newReverseEdge = Edge(sink, source,
capacity) if self.directed == False else Edge(
sink, source, 0)
newEdge.reverseEdge = newReverseEdge
newReverseEdge.reverseEdge = newEdge
self.graph[source].append(newEdge)
self.graph[sink].append(newReverseEdge)
def _generate_back(self):
a = self._l_t + Point3D(z=self._step_count * self._step_height)
b = a + Point3D(self._width)
self.triangles.append(Triangle(a, b, self._r_t))
self.triangles.append(Triangle(a, self._l_t, self._r_t))
self.edges.append(Edge(a, self._l_t))
self.edges.append(Edge(b, self._r_t))
def catmull(self):
self.meshMemory.append(
Mesh(self.vertexTable, self.edgeTable, self.faceTable))
newFaceTablePositions = []
vertexTable = []
faceTable = []
edgeTable = []
for faceObj in self.faceTable:
new_faces = self.findNewFacesFromFace(faceObj) #position list
for facePos in new_faces:
v1 = Vertex(facePos[0])
v2 = Vertex(facePos[1])
v3 = Vertex(facePos[2])
v4 = Vertex(facePos[3])
vertexTable.extend([v1, v2, v3, v4])
v1 = self.getVertexFromTheTable(v1, vertexTable)
v2 = self.getVertexFromTheTable(v2, vertexTable)
v3 = self.getVertexFromTheTable(v3, vertexTable)
v4 = self.getVertexFromTheTable(v4, vertexTable)
face = Face([v1, v2, v3, v4])
v1.addFace(face)
v2.addFace(face)
v3.addFace(face)
v4.addFace(face)
edge1 = Edge(v1, v2)
edge2 = Edge(v2, v3)
edge3 = Edge(v3, v4)
edge4 = Edge(v1, v4)
v1.addEdge(edge1, edge4)
v2.addEdge(edge1, edge2)
v3.addEdge(edge2, edge3)
v4.addEdge(edge3, edge4)
faceTable.append(face)
edgeTable.append(edge1)
edgeTable.append(edge2)
edgeTable.append(edge3)
edgeTable.append(edge4)
newFaceTablePositions.extend(new_faces)
self.faceTable = faceTable
self.edgeTable = edgeTable
self.vertexTable = vertexTable
return newFaceTablePositions
def main(args):
V = [Vertex("A"), Vertex("B"), Vertex("C"), Vertex("D"), Vertex("E")]
E = [Edge(9,V[0],V[1]), Edge(5,V[0],V[2]), Edge(10,V[0],V[4]), Edge(1,V[1],V[3]), Edge(11,V[2],V[3])]
G = Graph(V, E)
MST = kruskal(G)
print "================= Original Graph ======================"
print G
print "================= MST ======================"
print MST
def test_adjacentEdges(self):
self.graph.addEdge(0, 1)
self.graph.addEdge(0, 3)
self.graph.addEdge(1, 4)
adj_0 = self.graph.adjacentEdges(0)
adj_1 = self.graph.adjacentEdges(1)
self.assertEqual([Edge(0, 1), Edge(0, 3)], adj_0)
self.assertEqual([Edge(0, 1), Edge(1, 4)], adj_1)
def _get_edge_intersection_points(polygon1, polygon2):
intersection_points = list()
for i in range(len(polygon1)):
edge1 = Edge(polygon1[i - 1], polygon1[i])
for j in range(len(polygon2)):
edge2 = Edge(polygon2[j - 1], polygon2[j])
intersection_point = edge1.get_intersection_point(edge2)
if intersection_point is not None:
intersection_points.append(intersection_point)
return intersection_points
def replaceNodeWithNewInp(g, v):
fanout = g.fanout(v)
newInp = Node('Input_new_{}'.format(v.getName()))
g.addNode(newInp)
g.defineInput(newInp)
for u in fanout:
eToRem = Edge(v, u)
g.removeEdge(eToRem)
eToAdd = Edge(newInp, u)
g.addEdge(eToAdd)
def __one_hop_graph(self,
entity_items,
relation_items,
threshold=None,
number_of_entities=1):
top_uri = 1
total = self.count_combinations(entity_items, relation_items,
number_of_entities, top_uri)
if threshold is not None:
while total > threshold:
top_uri -= 0.1
total = self.count_combinations(entity_items, relation_items,
number_of_entities, top_uri)
with tqdm(total=total, disable=self.logger.level >= 10) as pbar:
for relation_item in relation_items:
for relation_uri in relation_item.top_uris(top_uri):
for entity_uris in itertools.product(
*
[items.top_uris(top_uri) for items in entity_items]):
for entity_uri in itertools.combinations(
entity_uris, number_of_entities):
pbar.update(1)
result = self.kb.one_hop_graph(
entity_uri[0], relation_uri,
entity_uri[1] if len(entity_uri) > 1 else None)
if result is not None:
for item in result:
m = int(item["m"]["value"])
uri = entity_uri[1] if len(
entity_uri) > 1 else 0
if m == 0:
n_s = self.create_or_get_node(
uri, True)
n_d = self.create_or_get_node(
entity_uri[0])
e = Edge(n_s, relation_uri, n_d)
self.add_edge(e)
elif m == 1:
n_s = self.create_or_get_node(
entity_uri[0])
n_d = self.create_or_get_node(
uri, True)
e = Edge(n_s, relation_uri, n_d)
self.add_edge(e)
elif m == 2:
n_s = self.create_or_get_node(uri)
n_d = self.create_or_get_node(
relation_uri)
e = Edge(
n_s,
Uri(self.kb.type_uri,
self.kb.parse_uri), n_d)
self.add_edge(e)
def _initialize_edge(self, row, col):
here = self._point(row, col)
# edge creation to right
if col < self.ncol:
down = self._point(row, col + 1)
self.edges.append(Edge(source=here, dest=down))
# edge creation to bottom
if row < self.nrow:
right = self._point(row + 1, col)
self.edges.append(Edge(source=here, dest=right))
def test_eq_ne(self):
self.assertTrue(self.edge == self.edge2)
self.assertFalse(self.edge != self.edge2)
edge3 = Edge(1, 2)
self.assertTrue(self.edge == edge3)
self.assertFalse(self.edge != edge3)
edge4 = Edge(1, 3)
self.assertFalse(edge3 == edge4)
self.assertTrue(edge3 != edge4)
def create_edges(self, max_x, max_y):
edges = []
for (x, y) in self.nodes:
me = self.nodes.get((x, y))
if x < max_x:
right = self.nodes.get(((x + 1), y))
edges.append(Edge(me, right))
if y < max_y:
down = self.nodes.get((x, (y + 1)))
edges.append(Edge(me, down))
return edges
