def make_complete_graph(num_nodes):
"""
Takes the number of nodes num_nodes and returns a dictionary
corresponding to a complete undirected graph with the specified
number of nodes.
"""
graph = {}
upa = alg.UPATrial(num_nodes)
for i in range(num_nodes):
if i not in graph:
graph[i] = set()
neighbors = upa.run_trial(num_nodes)
#print neighbors
for each in neighbors:
if each != i:
graph[i].add(each)
if (each in graph) and (each != i):
graph[each].add(i)
elif (each != i):
graph[each] = set()
graph[each].add(i)
return graph
def upa_graph(n, m):
# step 1: make a complete graph with m nodes
graph_dic = make_complete_graph(m)
graph = alg.UPATrial(m)
# step 2: add to graph from m to n nodes, one node per iteration
# for each iteration, add m out-degree to each new node
for i in range(m, n):
if i not in graph_dic:
graph_dic[i] = set()
number = random.randint(m, m + 1)
neighbors = graph.run_trial(number)
#print neighbors
for each in neighbors:
if each != i:
graph_dic[i].add(each)
if (each in graph_dic) and (each != i):
graph_dic[each].add(i)
elif (each != i):
graph_dic[each] = set()
graph_dic[each].add(i)
return graph_dic
def random_UPA_undirected_graph(num_nodes, m_nodes):
"""
Function uses the Undirected Preferential Attachment algoritm (UPA algorithm)
to create a random undirected graph. The UPA algorithm sets edges based on a
preferential attachment mechanism giving more edges to nodes created earlier
in the simulation.
Args:
num_nodes: integer, the numbe of nodes to be in the graph.
m_nodes: integer, the number of existing nodes to
which a new node is connected during each iteration.
Returns:
A dictionary representation of an undirected graph where keys are node names
and values are sets of neighbors.
"""
# Create an instance of UPATrial
upa_obj = alg_upa_trial.UPATrial(m_nodes)
# Make a complete ugraph with m nodes and add it to the final output
graph = make_complete_graph(m_nodes)
for node in range(m_nodes, num_nodes):
# Add neighbors to nodes
neighbors = upa_obj.run_trial(m_nodes)
graph[node] = neighbors
# Add nodes to neighbors
for n in neighbors:
graph[n].add(node)
return graph
def algorithm_upa(n, m):
graph = make_complete_graph(m)
upa = alg_upa_trial.UPATrial(m)
for i in xrange(m, n):
neighbors = upa.run_trial(m)
graph[i] = neighbors
for neighbor in neighbors:
graph[neighbor].add(i)
return graph
def load_upa_graph(total_nodes, m):
upa_graph = make_complete_graph(m)
upa_trial = upa.UPATrial(m)
for node in range(m, total_nodes):
upa_graph[node] = upa_trial.run_trial(m)
neighbors = upa_graph[node]
for neighbor in neighbors:
upa_graph[neighbor].add(node)
return upa_graph
def UPA(n, m):
assert 1 <= m <= n
ugraph = make_complete_graph(
m) # we first make a complete undirected graph
upa_obj = upa.UPATrial(m)
for i in range(m, n):
neighbours = upa_obj.run_trial(m)
ugraph[
i] = neighbours # each time we call 'run_trial' we use the constant amount of new edges 'm'
for neighbour in neighbours:
ugraph[neighbour].add(i)
return ugraph
def upa(n_nodes, m_nodes):
'''
Helper function to implement the UPA algorithm
'''
graph = make_complete_graph(m_nodes)
upa_alg = alg_upa_trial.UPATrial(m_nodes)
for node in range(m_nodes, n_nodes):
new_node_neighbors = upa_alg.run_trial(m_nodes)
graph[node] = new_node_neighbors
for neighbor in new_node_neighbors:
graph[neighbor].add(node)
return graph
def load_upa_graph(total_nodes, m):
"""
Returns a undirected graph with UPA algorithm
with parameters equal to the arguments.
"""
upa_graph = make_complete_graph(m)
upa_trial = upa.UPATrial(m)
for node in range(m, total_nodes):
upa_graph[node] = upa_trial.run_trial(m)
neighbors = upa_graph[node]
for neighbor in neighbors:
upa_graph[neighbor].add(node)
return upa_graph
def upa(num_nodes, num_new_nodes):
"""
Create undirected graph where every new node added randomly connects to a set
number of existing nodes.
"""
upa_graph = make_complete_graph(num_new_nodes)
graph = alg.UPATrial(num_new_nodes)
for num in range(num_new_nodes, num_nodes):
new_node_neighbors = graph.run_trial(num_new_nodes)
upa_graph[num] = new_node_neighbors
# make graph undirected
for neighbor in new_node_neighbors:
upa_graph[neighbor].add(num)
return upa_graph
def run_suite(
): # here we only pass a class reference, from which we are going to create an object later on
""" Some informal testing code """
print("\nSTARTING TESTS:")
suite = poc_simpletest.TestSuite() # create a TestSuite object
# 1. check the provided functions directly
suite.run_test(
app_2.targeted_order({
0: set([1, 2, 3]),
1: set([0, 2, 3]),
2: set([0, 1, 3]),
3: set([0, 1, 2])
}), [0, 1, 2, 3], "Test #1a: 'targeted_order' method"
) # all nodes are of same degree so returned the nodes from 0 to 3
suite.run_test(
app_2.targeted_order({
0: set([3]),
1: set([2, 3]),
2: set([1, 3]),
3: set([0, 1, 2])
}), [3, 1, 0, 2], "Test #1b: 'targeted_order' method"
) # after deleting node 3 and 1 there are only empty nodes left
# 2. check the basic functions directly
suite.run_test(app_2.random_ugraph(4, 1), {
0: set([1, 2, 3]),
1: set([0, 2, 3]),
2: set([0, 1, 3]),
3: set([0, 1, 2])
}, "Test #2a: 'random_digraph' method")
suite.run_test(app_2.random_ugraph(4, 0), {
0: set([]),
1: set([]),
2: set([]),
3: set([])
}, "Test #2b: 'random_digraph' method")
suite.run_test(
app_2.compute_edges({
0: set([1, 2, 3]),
1: set([0, 2, 3]),
2: set([0, 1, 3]),
3: set([0, 1, 2])
}), 6, "Test #2c: 'compute_edges' method")
suite.run_test(
app_2.compute_edges({
0: set([1, 2, 3, 4]),
1: set([0, 2, 3, 4]),
2: set([0, 1, 3, 4]),
3: set([0, 1, 2, 4]),
4: set([0, 1, 2, 3])
}), 10, "Test #2d: 'compute_edges' method")
suite.run_test(
app_2.compute_edges({
0: set([1, 2, 3, 4, 5]),
1: set([0, 2, 3, 4, 5]),
2: set([0, 1, 3, 4, 5]),
3: set([0, 1, 2, 4, 5]),
4: set([0, 1, 2, 3, 5]),
5: set([0, 1, 2, 3, 4])
}), 15, "Test #2e: 'compute_edges' method")
# 3. Testing basic functionality of the UPA CLASS
suite.run_test(
upa.UPATrial(3)._node_numbers, [0, 0, 0, 1, 1, 1, 2, 2, 2],
"Test #3a: 'self._node_numbers' property")
suite.run_test(
upa.UPATrial(4)._node_numbers,
[0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3],
"Test #3b: 'self._node_numbers' property")
suite.run_test_in_range_multi(
upa.UPATrial(3).run_trial(2), [0, 1, 2],
"Test #3c: 'run_trial' method")
# 4. check the basic functions directly
suite.run_test(
len(app_2.UPA(4, 2)), 4, "Test #4a: 'UPA' method"
) # here we just check if we get the total 'n' amount of nodes
suite.run_test(
len(
app_2.random_order({
0: set([]),
1: set([]),
2: set([]),
3: set([])
})), 4, "Test #4b: 'random_order' method")
# 5. check the basic functions directly
suite.run_test(
app_2.targeted_order_fast({
0: set([3]),
1: set([2, 3]),
2: set([1, 3]),
3: set([0, 1, 2])
}), [3, 1, 0, 2], "Test #5a: 'targeted_order_fast' method")
suite.run_test(app_2.targeted_order_fast(test_graphs.GRAPH2),
[1, 3, 5, 7, 8, 2, 4, 6],
"Test #5b: 'targeted_order_fast' method")
suite.run_test(app_2.targeted_order_fast(test_graphs.GRAPH5),
['banana', 'dog', 'cat', 'monkey', 'ape'],
"Test #5c: 'targeted_order_fast' method")
suite.run_test(app_2.targeted_order_fast(test_graphs.GRAPH8),
app_2.targeted_order(test_graphs.GRAPH8),
"Test #5d: 'targeted_order_fast' method")
suite.run_test(app_2.targeted_order_fast(test_graphs.GRAPH9),
app_2.targeted_order(test_graphs.GRAPH9),
"Test #5e: 'targeted_order_fast' method")
suite.run_test(app_2.targeted_order_fast(test_graphs.GRAPH10),
app_2.targeted_order(test_graphs.GRAPH10),
"Test #5f: 'targeted_order_fast' method")
suite.run_test(app_2.targeted_order_fast(test_graphs.GRAPH10),
app_2.targeted_order(test_graphs.GRAPH10),
"Test #5g: 'targeted_order_fast' method")
# 6. report number of tests and failures
suite.report_results()