Beispiel #1
0
def naive_scrump(T_A, m, T_B, percentage, exclusion_zone, pre_scrump, s):
    distance_matrix = naive.distance_matrix(T_A, T_B, m)

    n_A = T_A.shape[0]
    n_B = T_B.shape[0]
    l = n_A - m + 1

    if exclusion_zone is not None:
        diags = np.random.permutation(range(exclusion_zone + 1, n_A - m + 1))
    else:
        diags = np.random.permutation(range(-(n_A - m + 1) + 1, n_B - m + 1))

    n_chunks = int(np.ceil(1.0 / percentage))
    ndist_counts = core._count_diagonal_ndist(diags, m, n_A, n_B)
    diags_ranges = core._get_array_ranges(ndist_counts, n_chunks)
    diags_ranges_start = diags_ranges[0, 0]
    diags_ranges_stop = diags_ranges[0, 1]

    out = np.full((l, 4), np.inf, dtype=object)
    out[:, 1:] = -1
    left_P = np.full(l, np.inf, dtype=np.float64)
    right_P = np.full(l, np.inf, dtype=np.float64)

    for diag_idx in range(diags_ranges_start, diags_ranges_stop):
        k = diags[diag_idx]

        for i in range(n_A - m + 1):
            for j in range(n_B - m + 1):
                if j - i == k:
                    if distance_matrix[i, j] < out[i, 0]:
                        out[i, 0] = distance_matrix[i, j]
                        out[i, 1] = i + k

                    if (
                        exclusion_zone is not None
                        and distance_matrix[i, j] < out[i + k, 0]
                    ):
                        out[i + k, 0] = distance_matrix[i, j]
                        out[i + k, 1] = i

                    # left matrix profile and left matrix profile indices
                    if (
                        exclusion_zone is not None
                        and i < i + k
                        and distance_matrix[i, j] < left_P[i + k]
                    ):
                        left_P[i + k] = distance_matrix[i, j]
                        out[i + k, 2] = i

                    # right matrix profile and right matrix profile indices
                    if (
                        exclusion_zone is not None
                        and i + k > i
                        and distance_matrix[i, j] < right_P[i]
                    ):
                        right_P[i] = distance_matrix[i, j]
                        out[i, 3] = i + k

    return out
Beispiel #2
0
def test_count_diagonal_ndist():
    for n_A in range(10, 15):
        for n_B in range(10, 15):
            for m in range(3, 6):
                diags = np.random.permutation(range(-(n_A - m + 1) + 1, n_B - m + 1))
                ones_matrix = np.ones((n_A - m + 1, n_B - m + 1), dtype=np.int64)
                ref_ndist_counts = np.empty(len(diags))
                for i, diag in enumerate(diags):
                    ref_ndist_counts[i] = ones_matrix.diagonal(offset=diag).sum()

            comp_ndist_counts = core._count_diagonal_ndist(diags, m, n_A, n_B)

            npt.assert_almost_equal(ref_ndist_counts, comp_ndist_counts)