示例#1
0
def test_aamp_stimp_max_m(T):
    threshold = 0.2
    percentage = 0.01
    min_m = 3
    max_m = 5
    n = T.shape[0] - min_m + 1

    seed = np.random.randint(100000)

    np.random.seed(seed)
    pan = aamp_stimp(
        T,
        min_m=min_m,
        max_m=max_m,
        step=1,
        percentage=percentage,
        pre_scraamp=True,
    )

    for i in range(n):
        pan.update()

    ref_PAN = np.full((pan.M_.shape[0], T.shape[0]), fill_value=np.inf)

    np.random.seed(seed)
    for idx, m in enumerate(pan.M_[:n]):
        zone = int(np.ceil(m / 4))
        s = zone
        tmp_P, tmp_I = naive.prescraamp(T, m, T, s=s, exclusion_zone=zone)
        ref_mp = naive.scraamp(T, m, T, percentage, zone, True, s)
        for i in range(ref_mp.shape[0]):
            if tmp_P[i] < ref_mp[i, 0]:
                ref_mp[i, 0] = tmp_P[i]
                ref_mp[i, 1] = tmp_I[i]
        ref_PAN[pan._bfs_indices[idx], :ref_mp.shape[0]] = ref_mp[:, 0]

    # Compare raw pan
    cmp_PAN = pan._PAN

    naive.replace_inf(ref_PAN)
    naive.replace_inf(cmp_PAN)

    npt.assert_almost_equal(ref_PAN, cmp_PAN)

    # Compare transformed pan
    cmp_pan = pan.PAN_
    ref_pan = naive.transform_pan(
        pan._PAN,
        pan._M,
        threshold,
        pan._bfs_indices,
        pan._n_processed,
        np.min(T),
        np.max(T),
    )

    naive.replace_inf(ref_pan)
    naive.replace_inf(cmp_pan)

    npt.assert_almost_equal(ref_pan, cmp_pan)
示例#2
0
def test_prescraamp_self_join_larger_window(T_A, T_B, m):
    if len(T_B) > m:
        zone = int(np.ceil(m / 4))
        for s in range(1, zone + 1):
            seed = np.random.randint(100000)

            np.random.seed(seed)
            ref_P, ref_I = naive.prescraamp(T_B, m, T_B, s=s, exclusion_zone=zone)

            np.random.seed(seed)
            comp_P, comp_I = prescraamp(T_B, m, s=s)

            npt.assert_almost_equal(ref_P, comp_P)
            npt.assert_almost_equal(ref_I, comp_I)
示例#3
0
def test_prescraamp_A_B_join_swap(T_A, T_B):
    m = 3
    zone = int(np.ceil(m / 4))
    for s in range(1, zone + 1):
        seed = np.random.randint(100000)

        np.random.seed(seed)
        ref_P, ref_I = naive.prescraamp(T_B, m, T_A, s=s)

        np.random.seed(seed)
        comp_P, comp_I = prescraamp(T_B, m, T_B=T_A, s=s)

        npt.assert_almost_equal(ref_P, comp_P)
        npt.assert_almost_equal(ref_I, comp_I)
示例#4
0
def test_prescraamp_self_join(T_A, T_B):
    for p in [1.0, 2.0, 3.0]:
        m = 3
        zone = int(np.ceil(m / 4))
        for s in range(1, zone + 1):
            seed = np.random.randint(100000)

            np.random.seed(seed)
            ref_P, ref_I = naive.prescraamp(T_B, m, T_B, s=s, exclusion_zone=zone, p=p)

            np.random.seed(seed)
            comp_P, comp_I = prescraamp(T_B, m, s=s, p=p)

            npt.assert_almost_equal(ref_P, comp_P)
            npt.assert_almost_equal(ref_I, comp_I)
示例#5
0
def test_scraamp_plus_plus_A_B_join(T_A, T_B, percentages):
    m = 3
    zone = int(np.ceil(m / 4))

    for p in [1.0, 2.0, 3.0]:
        for s in range(1, zone + 1):
            for percentage in percentages:
                seed = np.random.randint(100000)

                np.random.seed(seed)
                ref_P, ref_I = naive.prescraamp(T_A, m, T_B, s=s, p=p)
                ref_mp = naive.scraamp(T_A, m, T_B, percentage, None, False, None, p=p)
                for i in range(ref_mp.shape[0]):
                    if ref_P[i] < ref_mp[i, 0]:
                        ref_mp[i, 0] = ref_P[i]
                        ref_mp[i, 1] = ref_I[i]
                ref_P = ref_mp[:, 0]
                ref_I = ref_mp[:, 1]
                ref_left_I = ref_mp[:, 2]
                ref_right_I = ref_mp[:, 3]

                approx = scraamp(
                    T_A,
                    m,
                    T_B,
                    ignore_trivial=False,
                    percentage=percentage,
                    pre_scraamp=True,
                    s=s,
                    p=p,
                )
                approx.update()
                comp_P = approx.P_
                comp_I = approx.I_
                comp_left_I = approx.left_I_
                comp_right_I = approx.right_I_

                naive.replace_inf(ref_P)
                naive.replace_inf(comp_P)

                npt.assert_almost_equal(ref_P, comp_P)
                npt.assert_almost_equal(ref_I, comp_I)
                npt.assert_almost_equal(ref_left_I, comp_left_I)
                npt.assert_almost_equal(ref_right_I, comp_right_I)