def test_add_edge_not_valid_vertex(self):
"""Tests the add_edge method in a graph with a non-existing vertex.
"""
graph = Graph(graph = { 'A' : [] })
graph.add_edge('A', 'B')
self.assertFalse(graph.has_edge('A', 'B'), 'No edge between A and non-existing B.')
def test_add_edge_effect_with_weight():
graph = Graph()
end = graph.add_node('coffee')
start = graph.add_node('muffin')
graph.add_edge(start, end, 44)
expected = (end, 44)
actual = graph._adjacency_list[start][0]
assert actual == expected
def test_add_edge_interloper_start():
graph = Graph()
start = Vertex('start')
end = graph.add_node('end')
with pytest.raises(KeyError):
graph.add_edge(start, end)
def erdos_renyi(n, p): g = Graph() for i in xrange(n): g.add_node(DiscreteVariable([0,1], name=str(i))) for i,j in itertools.product(xrange(n), xrange(n)): if random.random() < p: g.add_edge(g.get_node_by_name(str(i)),g.get_node_by_name(str(j))) return g
def test_get_neighbors():
graph = Graph()
end = graph.add_node('coffee')
start = graph.add_node('muffin')
graph.add_edge(start, end, 44)
neighbors = graph.get_neighbors(start)
assert len(neighbors) == 1
assert neighbors[0][0].value == 'coffee'
assert isinstance(neighbors[0][0], Vertex)
assert neighbors[0][1] == 44
def test_add_edge_undirected(self):
"""Tests the add_edge method for an undirected graph.
"""
graph = Graph(graph = { 'A' : [], 'B' : [] })
self.assertFalse(graph.has_edge('A', 'B'), 'There is no edge between A and B.')
graph.add_edge('A', 'B')
self.assertTrue(graph.has_edge('A', 'B'), 'There is now an edge between A and B.')
def read_edge_list_graph(infile):
"""Parse an edge-list formatted graph from `infile`."""
num_vertices = int(infile.readline())
graph = Graph(range(num_vertices))
for line in infile:
source, target = line.split(' ')
graph.add_edge(int(source), int(target))
return graph
def erdos_renyi(n, p):
g = Graph()
for i in xrange(n):
g.add_node(DiscreteVariable([0, 1], name=str(i)))
for i, j in itertools.product(xrange(n), xrange(n)):
if random.random() < p:
g.add_edge(g.get_node_by_name(str(i)), g.get_node_by_name(str(j)))
return g
def knight_graph(board_size):
# Build the graph
graph = Graph()
for row in range(board_size):
for col in range(board_size):
node_id = pos_to_node_id(row, col, board_size)
new_positions = generate_legal_moves(row, col, board_size)
for e in new_positions:
nid = pos_to_node_id(e[0], e[1], board_size)
graph.add_edge(node_id, nid)
return graph
def test_add_edge_directed(self):
"""Tests the add_edge method for a directed graph.
"""
graph = Graph(graph = { 'A' : [], 'B' : [] }, is_directed = True)
self.assertFalse(graph.has_edge('A', 'B'), 'There is no edge from A to B.')
self.assertFalse(graph.has_edge('B', 'A'), 'There is no edge from B to A.')
graph.add_edge('A', 'B')
self.assertTrue(graph.has_edge('A', 'B'), 'There is now an edge from A to B.')
self.assertFalse(graph.has_edge('B', 'A'), 'There is still no edge from B to A.')
def best_first_search_1(initial_state, goal_state=GOAL_STATE):
"""
Description
-----------
Best search algorithm using the number of tiles out of place as heuristic.
Example
-------
>>> initial_state = [1,2,3,8,5,6,7,4,0]
>>> best_first_search_1(initial_state)
[[1, 2, 3, 8, 5, 6, 7, 4, 0], [1, 2, 3, 8, 5, 0, 7, 4, 6], [1, 2, 3, 8, 0, 5, 7, 4, 6], ... ]
"""
graph = Graph(directed = True, root = initial_state)
# Uses a priority queue for a best search algorithm
stack = queue.PriorityQueue()
stack.put((0,initial_state,0))
visited = []
found_goal = False
while (stack.qsize() > 0) and (not found_goal):
priority, current_state, depth_counter = stack.get(block=False)
if not current_state in visited:
visited.append(current_state)
all_possible_states = find_all_possible_states_from(current_state)
# Compute priority based on the heuristic
for poss_state in all_possible_states:
out_of_place = 0
for pos,block in enumerate(poss_state):
if goal_state[pos] != block:
out_of_place += 1
priority = depth_counter + out_of_place
graph.add_edge(current_state, poss_state)
stack.put((priority, poss_state, depth_counter + 1))
if poss_state == goal_state:
visited.append(poss_state)
found_goal = True
break
return visited
def test_is_connected(self):
# Returns False for an empty graph
v, w = self.v, self.w
g = Graph([v, w], [])
eq_(g.is_connected(), False)
# Returns True for a complete graph
g.add_all_edges()
eq_(g.is_connected(), True)
# Returns False when a new vertex is added
x = Vertex('x')
g.add_vertex(x)
eq_(g.is_connected(), False)
# Returns True when edge is added to connect it
e2 = Edge(w, x)
g.add_edge(e2)
eq_(g.is_connected(), True)
def depth_first_search(initial_state, goal_state=GOAL_STATE):
"""
Description
-----------
Implements the depth first search algorithm.
Example
-------
>>> initial_state = [1,2,3,8,5,6,7,4,0]
>>> depth_first_search(initial_state)
[[1, 2, 3, 8, 5, 6, 7, 4, 0], [1, 2, 3, 8, 5, 0, 7, 4, 6], ... ]
"""
graph = Graph(directed = True, root = initial_state)
# Uses a stack for the depth first search
stack = [initial_state]
visited = []
found_goal = False
while (len(stack) > 0) and (not found_goal):
current_state = stack.pop()
if not current_state in visited:
visited.append(current_state)
all_possible_states = find_all_possible_states_from(current_state)
for state in all_possible_states:
graph.add_edge(current_state, state)
stack.append(state)
if state == goal_state:
visited.append(state)
found_goal = True
break
return visited
def breath_first_search(initial_state, goal_state=GOAL_STATE):
"""
Description
-----------
Implements the breath first search algorithm.
Example
-------
>>> initial_state = [1,2,3,8,5,6,7,4,0]
>>> breath_first_search(initial_state)
[[1, 2, 3, 8, 5, 6, 7, 4, 0], [1, 2, 3, 8, 5, 6, 7, 0, 4], [1, 2, 3, 8, 5, 0, 7, 4, 6], [1, 2, 3, 8, 5, 6, 0, 7, 4], ... ]
"""
graph = Graph(directed = True, root = initial_state)
# Using a queue for the breath first search
queue = deque([initial_state])
visited = []
found_goal = False
while (len(queue) > 0) and (not found_goal):
current_state = queue.popleft()
if not current_state in visited:
visited.append(current_state)
all_possible_states = find_all_possible_states_from(current_state)
for state in all_possible_states:
graph.add_edge(current_state, state)
queue.append(state)
if state == goal_state:
visited.append(state)
found_goal = True
break
return visited
def extract_connected_component(graph, needle):
subgraph = Graph([needle])
queue = [needle]
step = 0
while queue:
vertex = queue.pop(0)
step += 1
if step % 10000 == 0:
print(len(queue), repr(queue[0:min(5, len(queue))]))
step = 0
for (pred, obj) in graph.edges[vertex]:
# examine all neighbours of vertex
if not obj in subgraph.vertices:
# we haven't visited this vertex before
subgraph.add_vertex(obj)
subgraph.add_edge(vertex, obj, label=pred)
# we also needle to consider all new neighbours of `obj`
queue.append(obj)
elif (pred, obj) not in subgraph.edges[vertex]:
# we already have `obj`, but not this edge
subgraph.add_edge(vertex, obj, label=pred)
return subgraph
print("The maximum degree of the graph is:")
print(graph.Delta())
print("The minimum degree of the graph is:")
print(graph.delta())
print("Edges:")
print(graph.edges())
print("Degree Sequence: ")
ds = graph.degree_sequence()
print(ds)
fullfilling = [[2, 2, 2, 2, 1, 1], [3, 3, 3, 3, 3, 3], [3, 3, 2, 1, 1]]
non_fullfilling = [[4, 3, 2, 2, 2, 1, 1], [6, 6, 5, 4, 4, 2, 1], [3, 3, 3, 1]]
for sequence in fullfilling + non_fullfilling:
print(sequence, Graph.erdoes_gallai(sequence))
print("Add vertex 'z':")
graph.add_vertex("z")
print(graph)
print("Add edge ('x','y'): ")
graph.add_edge(('x', 'y'))
print(graph)
print("Add edge ('a','d'): ")
graph.add_edge(('a', 'd'))
print(graph)
from graphs import Graph
def dfs_visit(graph, source, parent, finished):
for u in graph.adj_list(source):
if u not in parent:
parent[u] = source
dfs_visit(graph, u, parent, finished)
finished.append(source)
def dfs(graph):
parent = {}
finished = []
vertices = graph.vertices()
for v in vertices:
if v not in parent:
parent[v] = None
dfs_visit(graph, v, parent, finished)
finished = list(reversed(finished))
return parent, finished
if __name__ == '__main__':
g = Graph()
for key in [1, 2, 3, 4]:
g.add_node(key)
g.add_edge(1, 2)
g.add_edge(2, 3)
g.add_edge(3, 4)
g.add_edge(4, 1)
print(dfs(g))
#!/usr/bin/python3
# Implement adjacency list
from graphs import Vertex, Graph
if __name__ == '__main__':
g = Graph()
for i in range(6):
g.add_vertex(i)
g.add_edge(0, 1, 5)
g.add_edge(0, 5, 2)
g.add_edge(1, 2, 4)
g.add_edge(2, 3, 9)
g.add_edge(3, 4, 7)
g.add_edge(3, 5, 3)
g.add_edge(4, 0, 1)
g.add_edge(5, 4, 8)
g.add_edge(5, 2, 1)
for v in g:
for w in v.get_connections():
print('({}, {})'.format(v.get_id(), w.get_id()))
from graphs import Graph
if __name__ == "__main__":
g = Graph()
g.add_edge(0, 1, 5)
g.add_edge(0, 5, 1)
g.add_edge(1, 2, 1)
g.add_edge(2, 4, 5)
g.add_edge(2, 6, 4)
g.add_edge(3, 2, 5)
g.add_edge(5, 8, 2)
g.add_edge(6, 5, 7) # uncomment to create cycle
g.add_edge(7, 5, 3)
g.add_edge(8, 6, 3) # uncomment to create cycle
g.add_edge(4, 1, 2) # uncomment to create cycle
#g.DFS()
g.BFS()
#g.print_debug()
#g.count_components()
def textRank(tokenized_words, tag_word_dict):
words_set = syntactic_filter(tag_word_dict)
# Add the vertex to the graph
graph_dict = {}
for w in words_set:
graph_dict[w] = []
graph = Graph(graph_dict)
# Add the edges
words = nltk.Text (tokenized_words)
doc = nltk.ConcordanceIndex(words)
for w in words_set:
results = get_concordance(w, doc)
for context in results:
left = context[0].split()
right = context[1].split()
for l in left:
if l in words_set:
graph.add_edge((w, l))
graph.add_edge((l, w))
for l in right:
if l in words_set:
graph.add_edge((w, l))
graph.add_edge((l, w))
# Run the text rank algorithm
delta = 1
i = 0
d = 0.85
while (delta > 0.0001 and i < 5000):
for v in graph.vertices():
degree = graph.vertex_degree(v)
old_rank = graph.text_rank(v)
sum = 0
for v2 in graph.adjacency_list(v):
degree2 = graph.vertex_degree(v2)
# print ("Degree for " + v2 + " = " + str(degree2))
tr = graph.text_rank(v2)
sum += tr / degree2
value = (1 - d) + d * sum
graph.set_text_rank(v, value)
if abs(value - old_rank) < delta:
delta = abs(value - old_rank)
i = i + 1
text_rank_dict = {}
for v in graph.vertices():
text_rank_dict[v] = graph.text_rank(v)
sorted_text_rank = sorted(text_rank_dict.items(), key=operator.itemgetter(1), reverse=True)
return sorted_text_rank
print(info)
VERTICES = info[0]
DEPOT = info[1]
REQUIRED_EDGES = info[2]
NON_REQUIRED_EDGES = info[3]
VEHICLES = info[4]
CAPACITY = info[5]
TOTAL_COST_OF_REQUIRED_EDGES = info[6]
# Build the graph
G = Graph(n=VERTICES, directed=False)
td = 0
for i in range(9, REQUIRED_EDGES + NON_REQUIRED_EDGES + 9):
G.add_edge(Edge(int(lines[i].strip().split()[0]),
int(lines[i].strip().split()[1]),
int(lines[i].strip().split()[2]),
int(lines[i].strip().split()[3])))
td += int(lines[i].strip().split()[3])
# Initialize a shortest path matrix
shortestPath = np.zeros((VERTICES + 1, VERTICES + 1))
shortestPath = np.int_(shortestPath)
for i in range(1, VERTICES+1):
algorithm = Dijkstra(G)
algorithm.run(i)
for j in range(i, VERTICES+1):
shortestPath[i][j] = algorithm.distance[j]
shortestPath = np.maximum(shortestPath, shortestPath.transpose())
shortestPath = shortestPath.tolist()
initial = time.time()
DEPOT = 1
REQUIRED_EDGES = int(lines[3].strip().split()[-1])
NON_REQUIRED_EDGES = int(lines[4].strip().split()[-1])
VEHICLES = int(lines[5].strip().split()[-1])
CAPACITY = int(lines[6].strip().split()[-1])
TOTAL_COST_OF_REQUIRED_EDGES = int(lines[8].strip().split()[-1])
f.close()
G = Graph(n=VERTICES, directed=False)
td = 0
for i in range(10, REQUIRED_EDGES + 10):
_ = re.split('[( , ) coste demanda \r\n]', lines[i])
_ = filter(lambda x: x != '', _)
td += int(_[3])
G.add_edge(Edge(int(_[0]), int(_[1]), int(_[2]), int(_[3])))
for i in range(11 + REQUIRED_EDGES, 11 + REQUIRED_EDGES + NON_REQUIRED_EDGES):
_ = re.split('[( , ) coste \r\n]', lines[i])
_ = filter(lambda x: x != '', _)
G.add_edge(Edge(int(_[0]), int(_[1]), int(_[2])))
'''
# def read_map(file_name):
info = np.zeros(7)
f = open('./CARP_samples/egl-s1-A.dat')
lines = f.readlines()
# Read map info to numpy array info
for i in range(1, 8):
info[i-1] = lines[i].strip().split()[-1]
f.close()
queue.append(start)
# do BFS
while(len(queue) > 0):
next_node = queue.pop(0)
for neighbor in graph.get_edges(next_node):
if neighbor not in visited:
queue.append(neighbor)
visited.append(next_node)
# print results
return {"reachable_nodes": visited}
# test
if __name__ == "__main__":
my_graph = Graph()
node1 = Node(10, 1)
node2 = Node(13, 2)
node3 = Node(20, 3)
my_graph.add_node(node1)
my_graph.add_edge((node2, node3))
my_graph.add_edge((node3, node1))
my_graph.print_nodes()
my_graph.print_edges()
print breadth_first_search(my_graph, node2)
def best_first_search_2(initial_state, goal_state=GOAL_STATE):
"""
Description
-----------
Best search algorithm using the minimum number moves to reach the goal state as heuristic.
Example
-------
>>> initial_state = [1,2,3,8,5,6,7,4,0]
>>> best_first_search_2(initial_state)
[[1, 2, 3, 8, 5, 6, 7, 4, 0], [1, 2, 3, 8, 5, 6, 7, 0, 4], [1, 2, 3, 8, 5, 6, 0, 7, 4], ... ]
"""
graph = Graph(directed = True, root = initial_state)
# Uses a priority queue for a best search algorithm
stack = queue.PriorityQueue()
stack.put((0,initial_state,0))
visited = []
found_goal = False
while (stack.qsize() > 0) and (not found_goal):
priority, current_state, depth_counter = stack.get(block=False)
if not current_state in visited:
visited.append(current_state)
all_possible_states = find_all_possible_states_from(current_state)
# Compute priority based on the heuristic
total_distance = 0
for poss_state in all_possible_states:
for pos,block in enumerate(poss_state):
if goal_state[pos] != block:
# Count vertical distance
desired_pos = goal_state.index(block)
def _get_row_level(p):
level = 0
if p >=0 and p < 3:
level = 1
elif p > 2 and p < 6:
level = 2
else:
level = 9
return level
pos_row_lvl = _get_row_level(pos)
des_pos_row_lvl = _get_row_level(desired_pos)
vertical_distance = abs(des_pos_row_lvl-pos_row_lvl)
# Count horizontal distance
horizontal_distance = abs((pos % 3) - (desired_pos % 3))
# Add to total distance
total_distance += vertical_distance + horizontal_distance
priority = depth_counter + total_distance
graph.add_edge(current_state, poss_state)
stack.put((priority, poss_state, depth_counter + 1))
if poss_state == goal_state:
visited.append(poss_state)
found_goal = True
break
return visited
def test_add_edge_works():
graph = Graph()
start = graph.add_node('start')
end = graph.add_node('end')
graph.add_edge(start, end)
def best_first_search_3(initial_state, goal_state=GOAL_STATE):
"""
Description
-----------
Best search algorithm using the total distance and sequence score as heuristic.
The "total distance" of the eight tiles in a board position from their "home squares". We use the Manhattan distance to calculate the distance of each tile from its home square.
The "sequence score" that measures the degree to which the tiles are already ordered in the current position with respect to the order required in the goal configuration.
Example
-------
>>> initial_state = [1,2,3,8,5,6,7,4,0]
>>> best_first_search_3(initial_state)
[[1, 2, 3, 8, 5, 6, 7, 4, 0], [1, 2, 3, 8, 5, 6, 7, 0, 4], [1, 2, 3, 8, 5, 6, 0, 7, 4], ... ]
"""
graph = Graph(directed = True, root = initial_state)
# Uses a priority queue for a best search algorithm
stack = queue.PriorityQueue()
stack.put((0,initial_state,0))
visited = []
found_goal = False
while (stack.qsize() > 0) and (not found_goal):
priority, current_state, depth_counter = stack.get(block=False)
if not current_state in visited:
visited.append(current_state)
all_possible_states = find_all_possible_states_from(current_state)
# Compute priority based on the heuristic
total_distance = 0
seq = 0
H = 0
for poss_state in all_possible_states:
for pos,block in enumerate(poss_state):
if goal_state[pos] != block:
# Compute the Total Distance for H
# Count vertical distance
desired_pos = goal_state.index(block)
def _get_row_level(p):
level = 0
if p >=0 and p < 3:
level = 1
elif p > 2 and p < 6:
level = 2
else:
level = 9
return level
pos_row_lvl = _get_row_level(pos)
des_pos_row_lvl = _get_row_level(desired_pos)
vertical_distance = abs(des_pos_row_lvl-pos_row_lvl)
# Count horizontal distance
horizontal_distance = abs((pos % 3) - (desired_pos % 3))
# Add to total distance
total_distance += vertical_distance + horizontal_distance
# Compute the Sequence Score
if pos == 4: # if it's the center block, then scores 1 to seq
seq += 1
else: # otherwise, scores 2 to seq
seq += 2
H = total_distance + 3 * seq
priority = depth_counter + H
graph.add_edge(current_state, poss_state)
stack.put((priority, poss_state, depth_counter + 1))
if poss_state == goal_state:
visited.append(poss_state)
found_goal = True
break
return visited
request = requests.get(SPARQL_ENDPOINT,
params={
'query': paged(page),
'format': 'json'
},
headers={'user-agent': USER_AGENT})
request.raise_for_status()
results = request.json()['results']['bindings']
done = len(results) <= PAGE_SIZE
page += 1
for binding in results:
v = ids[binding['v']['value']]
labels[v] = binding['vLabel']['value']
w = ids[binding['w']['value']]
labels[w] = binding['wLabel']['value']
edges |= {(w, v)}
graph = Graph(vertices=ids.values())
for (w, v) in edges:
graph.add_edge(w, v)
with open(args.output, 'w') as metis:
io.write_metis_graph(metis, graph)
with open(args.dict, 'w') as dictionary:
for vertex_id, label in labels.items():
print('{},"{}"'.format(vertex_id, label), file=dictionary)
def get_graph(my_orfs):
G = Graph(directed=True)
pgap = my_orfs.pstop
for orf in my_orfs.iter_orfs():
if(orf.frame > 0):
source = Node('CDS', 'start', orf.frame, orf.start)
target = Node('CDS', 'stop', orf.frame, orf.stop)
else:
source = Node('CDS', 'stop', orf.frame, orf.stop)
target = Node('CDS', 'start', orf.frame, orf.start)
G.add_edge(Edge(source, target, orf.weight))
#-------------------------------Check for long noncoding regions that would break the path---------#
bases = [None] * my_orfs.contig_length
for orfs in my_orfs.iter_in():
for orf in orfs:
mi = min(orf.start, orf.stop)
ma = max(orf.start, orf.stop)
for n in range(mi, min(ma, my_orfs.contig_length-1)):
try:
bases[n] = n
except:
sys.stderr.write("error in breaking region"+str(n))
break
last = 0
for base in bases:
if(base):
if(base-last > 300):
for right_node in G.iternodes():
for left_node in G.iternodes():
l = left_node.position
r = right_node.position
if(last+1 >= l > last-300 and base-1 <= r < base+300):
if(left_node.frame*right_node.frame > 0):
if(left_node.type == 'stop' and right_node.type =='start' and left_node.frame > 0):
score = score_gap(r-l-3, 'same', pgap)
G.add_edge(Edge(left_node, right_node, score))
elif(left_node.type == 'start' and right_node.type =='stop' and left_node.frame < 0):
score = score_gap(r-l-3, 'same', pgap)
G.add_edge(Edge(left_node, right_node, score ))
else:
if(left_node.type == 'stop' and right_node.type =='stop' and left_node.frame > 0):
score = score_gap(r-l-3, 'diff', pgap)
G.add_edge(Edge(left_node, right_node, score ))
elif(left_node.type == 'start' and right_node.type =='start' and left_node.frame < 0):
score = score_gap(r-l-3, 'diff',pgap)
G.add_edge(Edge(left_node, right_node, score ))
last = base
#-------------------------------Add in tRNA data---------------------------------------------------#
add_trnas(my_orfs, G)
#-------------------------------Connect the open reading frames to each other----------------------#
for right_node in G.iternodes():
r = right_node.position
if(right_node.gene == 'CDS'):
r_other = my_orfs.other_end[r]
else:
r_other = my_orfs.other_end['t'+str(r)]
for left_node in G.iternodes():
l = left_node.position
if(left_node.gene == 'CDS'):
l_other = my_orfs.other_end[l]
else:
l_other = my_orfs.other_end['t'+str(l)]
if(0 < r-l < 300):
if(l in my_orfs and my_orfs.other_end[l] in my_orfs[l]):
o1 = my_orfs.get_orf(my_orfs.other_end[l], l).pstop
elif(l in my_orfs):
o1 = my_orfs.get_orf(l, my_orfs.other_end[l]).pstop
else:
o1 = pgap
if(r in my_orfs and my_orfs.other_end[r] in my_orfs[r]):
o2 = my_orfs.get_orf(my_orfs.other_end[r], r).pstop
elif(r in my_orfs):
o2 = my_orfs.get_orf(r, my_orfs.other_end[r]).pstop
else:
o2 = pgap
pstop = ave([o1, o2])
#trna
if(left_node.gene == 'tRNA' or right_node.gene == 'tRNA'):
if(left_node.frame*right_node.frame > 0 and left_node.type != right_node.type):
if(left_node.frame > 0 and left_node.type == 'stop') or (left_node.frame < 0 and left_node.type == 'start'):
if not G.has_edge(Edge(left_node, right_node, 1)):
score = score_gap(r-l-3, 'same', pgap)
G.add_edge(Edge(left_node, right_node, score ))
elif(left_node.frame*right_node.frame < 0 and left_node.type == right_node.type):
if(left_node.frame > 0 and left_node.type == 'stop') or (left_node.frame < 0 and left_node.type == 'start'):
if not G.has_edge(Edge(left_node, right_node, 1)):
score = score_gap(r-l-3, 'same', pgap)
G.add_edge(Edge(left_node, right_node, score ))
# same directions
elif(left_node.frame*right_node.frame > 0):
if(left_node.type == 'stop' and right_node.type =='start'):
if(left_node.frame > 0):
score = score_gap(r-l-3, 'same', pgap)
G.add_edge(Edge(left_node, right_node, score ))
else:
if(left_node.frame != right_node.frame):
if(r < l_other and r_other < l):
score = score_overlap(r-l+3, 'same', pstop)
G.add_edge(Edge(right_node, left_node, score ))
if(left_node.type == 'start' and right_node.type =='stop'):
if(left_node.frame > 0):
if(left_node.frame != right_node.frame):
if(r < l_other and r_other < l):
score = score_overlap(r-l+3, 'same', pstop)
G.add_edge(Edge(right_node, left_node, score ))
else:
score = score_gap(r-l-3, 'same', pgap)
G.add_edge(Edge(left_node, right_node, score ))
# different directions
else:
if(left_node.type == 'stop' and right_node.type =='stop'):
if(right_node.frame > 0):
if(r_other+3 < l and r < l_other):
score = score_overlap(r-l+3, 'diff', pstop)
G.add_edge(Edge(right_node, left_node, score ))
else:
score = score_gap(r-l-3, 'diff', pgap)
G.add_edge(Edge(left_node, right_node, score ))
if(left_node.type == 'start' and right_node.type =='start'):
if(right_node.frame > 0 and r-l > 2):
score = score_gap(r-l-3, 'diff', pgap)
G.add_edge(Edge(left_node, right_node, score ))
elif(right_node.frame < 0):
#print(r_other, l, r, l_other)
if(r_other < l and r < l_other):
score = score_overlap(r-l+3, 'diff', pstop)
G.add_edge(Edge(right_node, left_node, score ))
#-------------------------------Connect open reading frames at both ends to a start and stop-------#
source = Node('source', 'source', 0, 0)
target = Node('target', 'target', 0, my_orfs.contig_length+1)
G.add_node(source)
G.add_node(target)
for node in G.iternodes():
if(node.position <= 2000):
if( (node.type == 'start' and node.frame > 0) or (node.type =='stop' and node.frame < 0) ):
score = score_gap(node.position, 'same', pgap)
G.add_edge(Edge(source, node, score))
if(my_orfs.contig_length - node.position <= 2000):
if( (node.type == 'start' and node.frame < 0) or (node.type =='stop' and node.frame > 0) ):
score = score_gap(my_orfs.contig_length-node.position, 'same', pgap)
G.add_edge(Edge(node, target, score))
return G
