예제 #1
0
def compute_ranges_for_loop(align, tree_info, mapping_t, node_index, ranges, ret_tuple_as_trans_desc):
    parent_node_index = tree_info[node_index].tree.parent.index
    if node_index == parent_node_index + 1:
        ub = tree_info[parent_node_index].tree_range.upper_bound
        nei_ranges = RangeInterval(tree_info[node_index].tree_range.upper_bound + 1, ub)
    else:
        lb = tree_info[parent_node_index].tree_range.lower_bound
        nei_ranges = RangeInterval(lb, tree_info[node_index].tree_range.lower_bound - 1)

    new_ranges = list()
    for range_interval in ranges:
        ri = compute_one_range_for_sequence(align, tree_info, mapping_t, node_index, range_interval,
                                            ret_tuple_as_trans_desc)
        if ri is not None:
            cur_pos = left_bound = ri.lower_bound
            while cur_pos <= ri.upper_bound:
                move = align[cur_pos]
                if not align_utils.is_log_move(move, ret_tuple_as_trans_desc):
                    move_cur_index = align_utils.move_index(move, mapping_t, ret_tuple_as_trans_desc)
                    move_in_nei = nei_ranges.is_in_range(move_cur_index)
                else:
                    move_in_nei = False
                if move_in_nei or cur_pos == ri.upper_bound:
                    new_ranges.append(compute_one_range_for_sequence(align, tree_info, mapping_t, node_index,
                                                                     RangeInterval(left_bound, cur_pos),
                                                                     ret_tuple_as_trans_desc))
                    ri = compute_one_range_for_sequence(align, tree_info, mapping_t, node_index,
                                                        RangeInterval(cur_pos + 1, ri.upper_bound),
                                                        ret_tuple_as_trans_desc)
                    if ri is None:
                        break
                    elif ri.upper_bound == ri.lower_bound:
                        new_ranges.append(RangeInterval(ri.lower_bound, ri.upper_bound))
                    left_bound = cur_pos = ri.lower_bound
                cur_pos += 1
    return new_ranges
예제 #2
0
def compute_ranges_for_loop(align, tree_info, mapping_t, node_index, ranges,
                            ret_tuple_as_trans_desc):
    parent_node_index = tree_info[node_index].tree.parent.index
    if node_index == parent_node_index + 1:
        ub = tree_info[parent_node_index].tree_range.upper_bound
        nei_ranges = RangeInterval(
            tree_info[node_index].tree_range.upper_bound + 1, ub)
    else:
        lb = tree_info[parent_node_index].tree_range.lower_bound
        nei_ranges = RangeInterval(
            lb, tree_info[node_index].tree_range.lower_bound - 1)

    new_ranges = list()
    for range_interval in ranges:
        ri = compute_one_range_for_sequence(align, tree_info, mapping_t,
                                            node_index, range_interval,
                                            nei_ranges, nei_ranges,
                                            ret_tuple_as_trans_desc)
        if ri is not None:
            left_bound = cur_pos = ri.lower_bound
            scatter_align = False
            while cur_pos <= ri.upper_bound:
                move = align[cur_pos]
                move_in_nei = True
                if not align_utils.is_log_move(move, ret_tuple_as_trans_desc):
                    move_cur_index = align_utils.move_index(
                        move, mapping_t, ret_tuple_as_trans_desc)
                    move_in_nei = nei_ranges.is_in_range(move_cur_index)
                    scatter_align = True if move_in_nei else scatter_align
                    if scatter_align and align_utils.move_in_subtree(
                            move, tree_info[node_index].tree_range, mapping_t):
                        new_ranges.append(
                            compute_one_range_for_sequence(
                                align, tree_info, mapping_t, node_index,
                                RangeInterval(left_bound,
                                              cur_pos - 1), nei_ranges,
                                nei_ranges, ret_tuple_as_trans_desc))
                        ri = compute_one_range_for_sequence(
                            align, tree_info, mapping_t, node_index,
                            RangeInterval(cur_pos, ri.upper_bound), nei_ranges,
                            nei_ranges, ret_tuple_as_trans_desc)
                        if ri is None:
                            break
                        left_bound = cur_pos = ri.lower_bound
                        scatter_align = False
                if (align_utils.is_sync_move(move, True)
                        and move_in_nei) or cur_pos == ri.upper_bound:
                    new_ranges.append(
                        compute_one_range_for_sequence(
                            align, tree_info, mapping_t, node_index,
                            RangeInterval(left_bound, cur_pos), nei_ranges,
                            nei_ranges, ret_tuple_as_trans_desc))
                    ri = compute_one_range_for_sequence(
                        align, tree_info, mapping_t, node_index,
                        RangeInterval(cur_pos + 1, ri.upper_bound), nei_ranges,
                        nei_ranges, ret_tuple_as_trans_desc)
                    if ri is None:
                        break
                    left_bound = cur_pos = ri.lower_bound
                    scatter_align = False
                else:
                    cur_pos += 1
    return new_ranges