def test_generate_partitions_of_bag_of_size():
#assemble
algo = alg.AlgorithmWorker(nx.Graph(), nx.Graph(), 0, 0)
max_size = 5
bag = set([1,2,3,4,5,6,7])
# act
result = algo.generate_partitions_of_bag_of_size(bag, max_size)
# assert
assert len(result) > 0
for partition1 in result:
for block1 in partition1.blocks:
assert len(block1) > 0, "A block should be nonempty"
assert len(block1) <= max_size, "A block should have size smaller than the max_size"
for block2 in partition1.blocks:
if(not block1 == block2):
assert len(set(block1) & set(block2)) == 0, "The intersection of every block should be the empty set"
flattened_blocks = [node for block in partition1.blocks for node in block]
assert set(flattened_blocks) == bag, "The union of all blocks should be the bag"
for partition2 in result:
if(not partition1 == partition2):
assert not partition1.blocks == partition2.blocks, "Every partition should be unique"
def test_calculate_component_signatures_of_introduce_node():
# assemble
nodes = [1, 2, 3, 4, 5, 6]
#nodes = [1, 2]
graph = nx.Graph()
graph.add_nodes_from(nodes)
graph.add_edges_from(
[[node1, node2] for node2 in nodes for node1 in nodes if not node1 == node2]
)
nice_td = nx.Graph()
h = 3
k = 6
algo = alg.AlgorithmWorker(graph, nice_td, h, k)
introduce_node = ntd.Nice_Tree_Node([2, 3, 4, 5])
#introduce_node = ntd.Nice_Tree_Node([1])
child_node = ntd.Nice_Tree_Node([2, 3, 5])
#child_node = ntd.Nice_Tree_Node([1, 2])
child_del_values = algo.find_component_signatures_of_leaf_nodes(child_node, child_node.bag)
# act
result = algo.calculate_component_signature_of_introduce_node(introduce_node, introduce_node.bag, child_node, child_node.bag, child_del_values)
print(result)
def test_find_component_signatures_of_leaf_nodes():
# assemble
nodes = [1, 2, 3, 4, 5, 6]
graph = nx.Graph()
graph.add_nodes_from(nodes)
graph.add_edges_from(
[[node1, node2] for node2 in nodes for node1 in nodes if not node1 == node2]
)
nice_tree_decomposition = nx.Graph()
h = 3
k = 6
algo = alg.AlgorithmWorker(graph, nice_tree_decomposition, h, k)
bag = ntd.Nice_Tree_Node([2, 3, 4, 5])
#act
result = algo.find_component_signatures_of_leaf_nodes(bag, bag.bag)
def test_algorithm3_function_generator():
algo = alg.AlgorithmWorker(nx.Graph(),nx.DiGraph(),0,0)
h = 10
dictionary = dict()
partition = alg.Partition([])
for x in range(1,11):
block = alg.Block([x])
partition.blocks.append(block)
dictionary[block] = x
last_block = alg.Block([11,12,13,14])
dictionary[last_block]=8
parent_function = alg.Function(dictionary)
refinements = algo.generate_partitions_of_bag_of_size(alg.Block([11,12,13]), len(alg.Block([11,12,13]))-1)
refinement = list(refinements)[0]
print(refinement)
result = algo.algorithm3_function_generator(parent_function, partition, last_block, refinement , 0)
for function1 in result:
for block in partition.blocks:
if block == last_block:
assert block in function1.dictionary, "Every block needs to be assigned a value"
for key1 in function1.dictionary:
assert function1.dictionary[key1] >= 1, "function(X) >= 1"
assert function1.dictionary[key1] <= h, "function(X) <= h"
for function2 in result:
if(not function1 == function2):
functions_are_unique = False
for key2 in function2.dictionary:
if(not function1.dictionary[key2] == function2.dictionary[key2]):
functions_are_unique = True
assert functions_are_unique, "Functions should be unique"
sum_of_refinement_blocks = 0
for block in function1.dictionary:
if block in partition:
assert function1[block] == parent_function[block], "c'(X) = c(X) not fulfilled"
# if block not in partition then it is a block of a refinement
else:
sum_of_refinement_blocks += function1[block]
assert parent_function[last_block]-1 == sum_of_refinement_blocks, "c(X_r) != sum of refinement block values"
def test_find_component_signatures_of_join_nodes():
# assemble
nodes = [1, 2, 3, 4, 5, 6]
graph = nx.Graph()
graph.add_nodes_from(nodes)
graph.add_edges_from(
[[node1, node2] for node2 in nodes for node1 in nodes if not node1 == node2]
)
nice_tree_decomposition = nx.Graph()
h = 3
k = 5
algo = alg.AlgorithmWorker(graph, nice_tree_decomposition, h, k)
TD_join_node = ntd.Nice_Tree_Node([2, 3, 4, 5])
TD_child_node_1 = ntd.Nice_Tree_Node([1, 2, 3, 4, 5])
TD_child_node_1_del_k = algo.find_component_signatures_of_leaf_nodes(TD_child_node_1, TD_child_node_1.bag)
TD_child_node_3 = ntd.Nice_Tree_Node([2,3,4,5])
TD_child_node_3_del_k = algo.find_component_signatures_of_forget_node(TD_child_node_3, TD_child_node_1, TD_child_node_1_del_k)
TD_child_node_2 = ntd.Nice_Tree_Node([2, 3, 4, 5])
TD_child_node_2_del_k = algo.find_component_signatures_of_leaf_nodes(TD_child_node_2, TD_child_node_2.bag)
# merge both dictionaries
TD_child_node_2_del_k.update(TD_child_node_3_del_k)
del_values_child = TD_child_node_2_del_k
#print(del_values_child)
# act
result = algo.find_component_signatures_of_join_nodes(TD_join_node, TD_join_node.bag, TD_child_node_3, TD_child_node_2, del_values_child)
# assert (lol)
for key, del_value in result.items():
print(del_value)
assert False
def test_generate_all_functions_of_partition():
# assemble
max_size = 7
algo = alg.AlgorithmWorker(nx.Graph(), nx.Graph(), max_size, 0)
partition = alg.Partition([alg.Block([1,2,6,4,5]), alg.Block([6,10,3]), alg.Block([9,7,11,12]), alg.Block([13,14,15,16])])
# act
result = algo.generate_all_functions_from_partition_to_range(partition, max_size)
for function1 in result:
for block in partition.blocks:
assert block in function1.dictionary, "Every block needs to be assigned a value"
for key1 in function1.dictionary:
assert function1.dictionary[key1] >= len(key1.node_list), "function(X) >= |X|"
assert function1.dictionary[key1] <= max_size, "function(X) <= h"
for function2 in result:
if(not function1 == function2):
functions_are_unique = False
for key2 in function2.dictionary:
assert key2 in function1.dictionary, "every function should have the same keys"
if(not function1.dictionary[key2] == function2.dictionary[key2]):
functions_are_unique = True
assert functions_are_unique, "Functions should be unique"