def exercise_knot():
edge_sets = utils.construct_edge_sets(n_vertices=4,
edge_list=[(0, 1), (1, 2), (2, 3),
(1, 3)])
expected_loops_dendrites = [({}, {
2: [set([1]), set([1, 3])],
3: [set([1, 2]), set([1])]
}), ({
2: [[3]],
3: [[2]]
}, {
2: [set([3])],
3: [set([2])]
}), ({
1: [[3]],
3: [[1]]
}, {
0: [set([1])],
1: [set([3])],
3: [set([1])]
}), ({
1: [[2]],
2: [[1]]
}, {
0: [set([1])],
1: [set([2])],
2: [set([1])]
})]
for iv in xrange(4):
loop_dendrites = find_paths(edge_sets=edge_sets).search_from(iv=iv)
assert loop_dendrites == expected_loops_dendrites[iv]
def exercise_simple_loops(loop_size_max=10):
for n_vertices in xrange(3, loop_size_max + 1):
edge_list = [
tuple(sorted((i, (i + 1) % n_vertices)))
for i in xrange(n_vertices)
]
edge_sets = utils.construct_edge_sets(n_vertices=n_vertices,
edge_list=edge_list)
loops, dendrites = find_paths(edge_sets=edge_sets).search_from(iv=0)
if (n_vertices <= 7):
assert len(loops) == 2
assert sorted(dendrites.keys()) == range(1, n_vertices)
else:
assert len(loops) == 0
assert sorted(dendrites.keys()) == range(2, n_vertices - 1)
if (n_vertices == 3):
assert loops == {1: [[2]], 2: [[1]]}
assert dendrites == {1: [set([2])], 2: [set([1])]}
elif (n_vertices == 4):
assert loops == {1: [[2, 3]], 3: [[2, 1]]}
assert dendrites == {
1: [set([2, 3])],
2: [set([1]), set([3])],
3: [set([1, 2])]
}
def exercise_knot():
edge_sets = utils.construct_edge_sets(
n_vertices=4,
edge_list=[(0,1), (1,2), (2,3), (1,3)])
expected_loops_dendrites = [
({}, {2: [set([1]), set([1, 3])], 3: [set([1, 2]), set([1])]}),
({2: [[3]], 3: [[2]]}, {2: [set([3])], 3: [set([2])]}),
({1: [[3]], 3: [[1]]}, {0: [set([1])], 1: [set([3])], 3: [set([1])]}),
({1: [[2]], 2: [[1]]}, {0: [set([1])], 1: [set([2])], 2: [set([1])]})]
for iv in xrange(4):
loop_dendrites = find_paths(edge_sets=edge_sets).search_from(iv=iv)
assert loop_dendrites == expected_loops_dendrites[iv]
def exercise_test_cases(out):
for i_tc, tc in enumerate(test_cases):
print("test_case index:", i_tc, file=out)
print(tc.art, file=out)
tc_c1, tc_he1, tc_r1, tc_tid1, tc_le1, tc_leb1, \
tc_c2, tc_he2, tc_le2, tc_leb2 = \
tc.clusters1, tc.hinge_edges1, \
tc.roots1, tc.tree_ids1, tc.loop_edges1, tc.loop_edge_bendings1, \
tc.clusters1, tc.hinge_edges1, tc.loop_edges1, tc.loop_edge_bendings1
def assert_same(label, have, expected):
print(label, have, file=out)
if (expected is not None):
if (have != expected):
print("expected:", expected, file=out)
assert have == expected, "Note: --verbose for details"
#
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
cm = tt.cluster_manager
assert_same("c1:", cm.clusters, tc_c1)
cm.construct_spanning_trees(edge_sets=tt.edge_sets)
print("c1t:", cm.clusters, file=out)
assert_same("he1:", cm.hinge_edges, tc_he1)
assert_same("le1:", cm.loop_edges, tc_le1)
r = cm.roots()
assert_same("r1:", r, tc_r1)
tid = cm.tree_ids()
assert_same("tid1:", tid, tc_tid1)
cm.find_loop_edge_bendings(edge_sets=tt.edge_sets)
assert_same("leb1:", cm.loop_edge_bendings, tc_leb1)
#
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
cm = tt.cluster_manager
cm.merge_clusters_with_multiple_connections(edge_sets=tt.edge_sets)
assert_same("c2:", cm.clusters, tc_c2)
cm.construct_spanning_trees(edge_sets=tt.edge_sets)
print("c2t:", cm.clusters, file=out)
assert_same("he2:", cm.hinge_edges, tc_he2)
assert_same("le2:", cm.loop_edges, tc_le2)
cm.find_loop_edge_bendings(edge_sets=tt.edge_sets)
assert_same("leb2:", cm.loop_edge_bendings, tc_leb2)
#
fp = find_paths(edge_sets=tt.edge_sets)
for iv in range(len(tt.edge_sets)):
fp.search_from(iv=iv)
#
print(file=out)
def exercise_test_cases(out):
for i_tc,tc in enumerate(test_cases):
print >> out, "test_case index:", i_tc
print >> out, tc.art
tc_c1, tc_he1, tc_r1, tc_tid1, tc_le1, tc_leb1, \
tc_c2, tc_he2, tc_le2, tc_leb2 = \
tc.clusters1, tc.hinge_edges1, \
tc.roots1, tc.tree_ids1, tc.loop_edges1, tc.loop_edge_bendings1, \
tc.clusters1, tc.hinge_edges1, tc.loop_edges1, tc.loop_edge_bendings1
def assert_same(label, have, expected):
print >> out, label, have
if (expected is not None):
if (have != expected):
print >> out, "expected:", expected
assert have == expected, "Note: --verbose for details"
#
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
cm = tt.cluster_manager
assert_same("c1:", cm.clusters, tc_c1)
cm.construct_spanning_trees(edge_sets=tt.edge_sets)
print >> out, "c1t:", cm.clusters
assert_same("he1:", cm.hinge_edges, tc_he1)
assert_same("le1:", cm.loop_edges, tc_le1)
r = cm.roots()
assert_same("r1:", r, tc_r1)
tid = cm.tree_ids()
assert_same("tid1:", tid, tc_tid1)
cm.find_loop_edge_bendings(edge_sets=tt.edge_sets)
assert_same("leb1:", cm.loop_edge_bendings, tc_leb1)
#
tt = construct(n_vertices=tc.n_vertices, edge_list=tc.edge_list)
cm = tt.cluster_manager
cm.merge_clusters_with_multiple_connections(edge_sets=tt.edge_sets)
assert_same("c2:", cm.clusters, tc_c2)
cm.construct_spanning_trees(edge_sets=tt.edge_sets)
print >> out, "c2t:", cm.clusters
assert_same("he2:", cm.hinge_edges, tc_he2)
assert_same("le2:", cm.loop_edges, tc_le2)
cm.find_loop_edge_bendings(edge_sets=tt.edge_sets)
assert_same("leb2:", cm.loop_edge_bendings, tc_leb2)
#
fp = find_paths(edge_sets=tt.edge_sets)
for iv in xrange(len(tt.edge_sets)):
fp.search_from(iv=iv)
#
print >> out
def exercise_simple_loops(loop_size_max=10):
for n_vertices in xrange(3, loop_size_max+1):
edge_list = [tuple(sorted((i,(i+1)%n_vertices)))
for i in xrange(n_vertices)]
edge_sets = utils.construct_edge_sets(
n_vertices=n_vertices, edge_list=edge_list)
loops, dendrites = find_paths(edge_sets=edge_sets).search_from(iv=0)
if (n_vertices <= 7):
assert len(loops) == 2
assert sorted(dendrites.keys()) == range(1,n_vertices)
else:
assert len(loops) == 0
assert sorted(dendrites.keys()) == range(2,n_vertices-1)
if (n_vertices == 3):
assert loops == {1: [[2]], 2: [[1]]}
assert dendrites == {1: [set([2])], 2: [set([1])]}
elif (n_vertices == 4):
assert loops == {1: [[2, 3]], 3: [[2, 1]]}
assert dendrites == {
1: [set([2, 3])], 2: [set([1]), set([3])], 3: [set([1, 2])]}
def exercise_minimal():
edge_sets = utils.construct_edge_sets(n_vertices=1, edge_list=[])
assert find_paths(edge_sets=edge_sets).search_from(iv=0) == ({}, {})
edge_sets = utils.construct_edge_sets(n_vertices=2, edge_list=[(0, 1)])
for iv in [0, 1]:
assert find_paths(edge_sets=edge_sets).search_from(iv=iv) == ({}, {})
def exercise_minimal():
edge_sets = utils.construct_edge_sets(n_vertices=1, edge_list=[])
assert find_paths(edge_sets=edge_sets).search_from(iv=0) == ({}, {})
edge_sets = utils.construct_edge_sets(n_vertices=2, edge_list=[(0,1)])
for iv in [0,1]:
assert find_paths(edge_sets=edge_sets).search_from(iv=iv) == ({}, {})
