def test_second_split(graph, initial_partition): vertexes, q_partition = decorate_nx_graph(graph, initial_partition) xblock = q_partition[0].xblock qblock_splitter = q_partition[0] # qblock_splitter may be modified by split, therefore we need to keep a # copy splitter_vertexes = [vertex for vertex in qblock_splitter.vertexes] block_counterimage = build_block_counterimage(qblock_splitter) new_qblocks, _, _ = split(block_counterimage) q_partition.extend(new_qblocks) second_splitter_vertexes = list( filter(lambda vertex: vertex not in splitter_vertexes, vertexes)) # E^{-1}(B) - E^{-1}(S-B) second_splitter_counterimage = build_exclusive_B_counterimage( splitter_vertexes) new_qblocks, _, _ = split(second_splitter_counterimage) q_partition.extend(new_qblocks) # after split the partition should be stable with respect to the block # chosen for the split for qblock in xblock.qblocks: assert check_vertexes_stability([vertex for vertex in qblock.vertexes], second_splitter_vertexes)
def test_second_splitter_counterimage(graph, initial_partition): vertexes, q_partition = decorate_nx_graph(graph, initial_partition) xblock = q_partition[0].xblock qblock_splitter = q_partition[0] # qblock_splitter may be modified by split, therefore we need to keep a # copy splitter_vertexes = [vertex for vertex in qblock_splitter.vertexes] block_counterimage = build_block_counterimage(qblock_splitter) split(block_counterimage) # compute S - B second_splitter_s_minus_b_vertexes = list( filter(lambda vertex: vertex not in splitter_vertexes, vertexes)) # use the pta function to compute E^{-1}(B) - E^{-1}(S-B) second_splitter_counterimage = build_exclusive_B_counterimage( splitter_vertexes) for vertex in second_splitter_counterimage: assert vertex in block_counterimage and not any( map( lambda edge: edge in second_splitter_s_minus_b_vertexes, vertex.image, ))
def test_split(graph, initial_partition): vertexes, q_partition = decorate_nx_graph(graph, initial_partition) xblock = q_partition[0].xblock qblock_splitter = q_partition[0] # qblock_splitter may be modified by split, therefore we need to keep a # copy splitter_vertexes = [vertex for vertex in qblock_splitter.vertexes] block_counterimage = build_block_counterimage(qblock_splitter) split(block_counterimage) # after split the partition should be stable with respect to the block # chosen for the split for qblock in xblock.qblocks: assert check_vertexes_stability([vertex for vertex in qblock.vertexes], splitter_vertexes) # test if the size of the qblocks after the split is equal to the number of # vertexes for qblock in xblock.qblocks: assert qblock.size == len(qblock.vertexes) # check if the qblock a vertex belongs to corresponds to the value # vertex.qblock for each of its vertexes for qblock in xblock.qblocks: for vertex in qblock.vertexes: assert vertex.qblock == qblock
def test_vertex_taken_from_right_list(graph, initial_partition): vertexes, q_partition = decorate_nx_graph(graph, initial_partition) block_counterimage = build_block_counterimage(q_partition[0]) for vertex in block_counterimage: qblock = vertex.qblock # this shouldn't raise an exception qblock.remove_vertex(vertex) assert True
def test_increase_n_of_xblocks_after_refinement(graph, initial_partition): vertexes_dllistobejct, q_partition = decorate_nx_graph( graph, initial_partition) xblock = q_partition[0].xblock xblocks = [xblock] compound_xblocks = [xblock] qblock_splitter = q_partition[0] block_counterimage = build_block_counterimage(qblock_splitter) refine(xblocks=xblocks, compound_xblocks=compound_xblocks) assert len(xblocks) == 2
def test_build_block_counterimage(graph, initial_partition): vertexes, q_partition = decorate_nx_graph(graph, initial_partition) for qblock in q_partition: def extract_vertex_label(llistobject): return llistobject.label block_counterimage = set( [vertex.label for vertex in build_block_counterimage(qblock)]) right_block_counterimage = set() for edge in graph.edges: if edge[1] in list( map(lambda vertex: vertex.label, qblock.vertexes)): right_block_counterimage.add(edge[0]) assert right_block_counterimage == block_counterimage
def ranked_split(current_partition: List[_QBlock], B_qblock: _QBlock, max_rank: int) -> List[Tuple[_Vertex]]: """Split the given partition using the block `B_qblock` as *splitter*, then use Ranked *Paige-Tarjan*'s algorithm on the resulting partition. :param current_partition: The current partition as a list of :class:`bispy.utilities.graph_entities._QBlock`. :param B_qblock: The block to be used as *splitter*. :param max_rank: The maximum rank which may be found in the graph. :returns: The output of Ranked *Paige-Tarjan*'s algorithm as a list of tuples of vertexes. """ # initialize x_partition and q_partition x_partition = [ # this also overwrites any information about parent xblocks for qblock _XBlock().append_qblock(qblock) for qblock in current_partition ] q_partition = current_partition # perform Split(B,Q) B_counterimage = build_block_counterimage(B_qblock) new_qblocks, new_compound_xblocks, chaned_qblocks = split(B_counterimage) # reset aux_count for vx in B_counterimage: vx.aux_count = None q_partition.extend(new_qblocks) if max_rank == float("-inf"): max_rank = -1 # note that only new compound xblock are compound xblocks compound_xblocks = RankedCompoundXBlocksContainer(new_compound_xblocks, max_rank) return pta(x_partition, q_partition, compound_xblocks)
def test_build_block_counterimage_aux_count(graph, initial_partition): vertexes, q_partition = decorate_nx_graph(graph, initial_partition) for chosen_index in range(len(initial_partition)): qblock = q_partition[chosen_index] block_counterimage = build_block_counterimage(qblock) right_count = [0 for vertex in block_counterimage] for edge in graph.edges: if edge[1] in list( map(lambda vertex: vertex.label, qblock.vertexes)): # update the count for edge[0] for idx in range(len(block_counterimage)): if block_counterimage[idx].label == edge[0]: right_count[idx] += 1 assert right_count == [ vertex.aux_count.value for vertex in block_counterimage ] for vertex in block_counterimage: vertex.aux_count = None