How to use the matrixprofile.scrimp.fast_find_nn_pre function in matrixprofile

def test_calc_idx_diff():
    ts = [1, 2, 3, 4, 5, 6, 7, 8]
    m = 4

    # test index 0
    idx = 0
    profile_len = scrimp.calc_profile_len(len(ts), m)
    exclusion_zone = scrimp.calc_exclusion_zone(m)
    subsequence = scrimp.next_subsequence(ts, idx, m)
    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    dp = scrimp.calc_distance_profile(X, subsequence, n, m, meanx, sigmax)
    dp = scrimp.apply_exclusion_zone(idx, exclusion_zone, profile_len, dp)

    mp = np.zeros(profile_len)
    mp_index = np.zeros(profile_len, dtype='int32')

    mp, mp_index, idx_nn = scrimp.find_and_store_nn(0, idx, mp, mp_index, dp)

    idx_diff = scrimp.calc_idx_diff(idx, idx_nn)
    expected_idx_diff = 2

    assert(idx_diff == expected_idx_diff)

def test_fast_find_nn_pre():
    """Validate the computations for fast find nn pre."""
    ts = np.array([1, 2, 3, 4, 5, 6, 7, 8])
    m = 4

    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    assert(n == 8)

    expected_sumx2 = np.array([30, 54, 86, 126, 174])
    assert((sumx2 == expected_sumx2)).all()

    expected_sumx = np.array([10, 14, 18, 22, 26])
    assert((sumx == expected_sumx)).all()

    expected_meanx = np.array([2.5, 3.5, 4.5, 5.5, 6.5])
    assert((meanx == expected_meanx).all())

    expected_sigmax2 = np.array([1.25, 1.25, 1.25, 1.25, 1.25])
    assert(np.allclose(sigmax2, expected_sigmax2))

    expected_sigmax = np.array([1.118, 1.118, 1.118, 1.118, 1.118])
    assert(np.allclose(sigmax, expected_sigmax, 1e-02))

def test_calc_distance_profile():
    ts = [1, 2, 3, 4, 5, 6, 7, 8]
    m = 4
    idx = 0

    expected_dp = np.array([
        4.21468485e-08,
        4.21468485e-08,
        0.00000000e+00,
        4.21468485e-08,
        4.21468485e-08
    ])

    subsequence = scrimp.next_subsequence(ts, idx, m)
    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    dp = scrimp.calc_distance_profile(X, subsequence, n, m, meanx, sigmax)

    np.testing.assert_almost_equal(dp, expected_dp)

    # test idx 1
    idx = 1

    expected_dp = np.array([
        4.21468485e-08,
        4.21468485e-08,
        4.21468485e-08,
        4.21468485e-08,
        4.21468485e-08
    ])

    subsequence = scrimp.next_subsequence(ts, idx, m)

def test_apply_exclusion_zone():
    ts = [1, 2, 3, 4, 5, 6, 7, 8]
    m = 4

    # test index 0
    idx = 0
    profile_len = scrimp.calc_profile_len(len(ts), m)  # 4
    exclusion_zone = scrimp.calc_exclusion_zone(m)  # 1
    subsequence = scrimp.next_subsequence(ts, idx, m)
    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    dp = scrimp.calc_distance_profile(X, subsequence, n, m, meanx, sigmax)
    dp = scrimp.apply_exclusion_zone(idx, exclusion_zone, profile_len, dp)

    expected_dp = np.array([
        np.inf,
        np.inf,
        0.4215e-07,
        0.4215e-07,
        0.4215e-07,
    ])

    np.testing.assert_almost_equal(dp, expected_dp)

    # test idx 1
    idx = 1
    subsequence = scrimp.next_subsequence(ts, idx, m)

def test_find_and_store_nn():
    ts = [1, 2, 3, 4, 5, 6, 7, 8]
    m = 4

    # test index 0
    idx = 0
    profile_len = scrimp.calc_profile_len(len(ts), m)
    exclusion_zone = scrimp.calc_exclusion_zone(m)
    subsequence = scrimp.next_subsequence(ts, idx, m)
    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    dp = scrimp.calc_distance_profile(X, subsequence, n, m, meanx, sigmax)
    dp = scrimp.apply_exclusion_zone(idx, exclusion_zone, profile_len, dp)

    mp = np.zeros(profile_len)
    mp_index = np.zeros(profile_len, dtype='int32')

    mp, mp_index, idx_nn = scrimp.find_and_store_nn(0, idx, mp, mp_index, dp)
    expected_mp = np.array([
        0.4215e-07,
        np.inf,
        0.4215e-07,
        0.4215e-07,
        0.4215e-07,
    ])
    expected_idx_nn = 2
    expected_mp_index = np.array([

def test_calc_refine_distance_end_idx():
    ts = [1, 2, 3, 4, 5, 6, 7, 8]
    m = 4
    step_size = 0.25

    # test index 0
    idx = 0
    profile_len = scrimp.calc_profile_len(len(ts), m)
    exclusion_zone = scrimp.calc_exclusion_zone(m)
    subsequence = scrimp.next_subsequence(ts, idx, m)
    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    dp = scrimp.calc_distance_profile(X, subsequence, n, m, meanx, sigmax)
    dp = scrimp.apply_exclusion_zone(idx, exclusion_zone, profile_len, dp)
    mp = np.zeros(profile_len)
    mp_index = np.zeros(profile_len, dtype='int32')
    mp, mp_index, idx_nn = scrimp.find_and_store_nn(0, idx, mp, mp_index, dp)
    idx_diff = scrimp.calc_idx_diff(idx, idx_nn)
    step_size = scrimp.calc_step_size(m, step_size)
    endidx = scrimp.calc_end_idx(profile_len, idx, step_size, idx_diff)
    refine_distance = np.full(profile_len, np.inf)
    result = scrimp.calc_refine_distance_end_idx(
        refine_distance, dp, idx, endidx, meanx, sigmax, idx_nn, idx_diff, m)
    expected_result = np.array([np.inf, np.inf, np.inf, np.inf, np.inf])

    np.testing.assert_almost_equal(result, expected_result)

def test_calc_dotproduct_idx():
    ts = [1, 2, 3, 4, 5, 6, 7, 8]
    m = 4

    # test index 0
    idx = 0
    profile_len = scrimp.calc_profile_len(len(ts), m)
    exclusion_zone = scrimp.calc_exclusion_zone(m)
    subsequence = scrimp.next_subsequence(ts, idx, m)
    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    dp = scrimp.calc_distance_profile(X, subsequence, n, m, meanx, sigmax)
    dp = scrimp.apply_exclusion_zone(idx, exclusion_zone, profile_len, dp)
    mp = np.zeros(profile_len)
    mp_index = np.zeros(profile_len, dtype='int32')
    mp, mp_index, idx_nn = scrimp.find_and_store_nn(0, idx, mp, mp_index, dp)
    dotproduct = np.zeros(profile_len)
    val = scrimp.calc_dotproduct_idx(dotproduct, m, mp, idx,
                                     sigmax, idx_nn, meanx)
    expected_val = np.array([50, 0, 0, 0, 0])

    np.testing.assert_almost_equal(val, expected_val)

def test_calc_curdistance():
    ts = np.array([1, 2, 3, 4, 5, 6, 7, 8])
    m = 4

    # test index 2
    idx = 2
    profile_len = scrimp.calc_profile_len(len(ts), m)
    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    curlastz = np.zeros(profile_len)
    curlastz = scrimp.calc_curlastz(ts, m, n, idx, profile_len, curlastz)

    curdistance = np.zeros(profile_len)
    curdistance = scrimp.calc_curdistance(curlastz, meanx, sigmax, idx, 
                                          profile_len, m, curdistance)

    expected_result = np.array([
        0,
        0,
        0.4215e-07,
        0.4215e-07,
        0.4215e-07,
    ])

    np.testing.assert_almost_equal(curdistance, expected_result)

def test_calc_refine_distance_begin_idx():
    ts = [1, 2, 3, 4, 5, 6, 7, 8]
    m = 4
    step_size = 0.25

    # test index 0
    idx = 0
    profile_len = scrimp.calc_profile_len(len(ts), m)
    exclusion_zone = scrimp.calc_exclusion_zone(m)
    subsequence = scrimp.next_subsequence(ts, idx, m)
    X, n, sumx2, sumx, meanx, sigmax2, sigmax = scrimp.fast_find_nn_pre(ts, m)
    dp = scrimp.calc_distance_profile(X, subsequence, n, m, meanx, sigmax)
    dp = scrimp.apply_exclusion_zone(idx, exclusion_zone, profile_len, dp)
    mp = np.zeros(profile_len)
    mp_index = np.zeros(profile_len, dtype='int32')
    mp, mp_index, idx_nn = scrimp.find_and_store_nn(0, idx, mp, mp_index, dp)
    idx_diff = scrimp.calc_idx_diff(idx, idx_nn)
    step_size = scrimp.calc_step_size(m, step_size)
    beginidx = scrimp.calc_begin_idx(idx, step_size, idx_diff)

    refine_distance = np.full(profile_len, np.inf)
    result = scrimp.calc_refine_distance_begin_idx(
        refine_distance, dp, beginidx, idx, idx_diff, idx_nn, sigmax, meanx, m)
    expected_result = np.array([np.inf, np.inf, np.inf, np.inf, np.inf])

    np.testing.assert_almost_equal(result, expected_result)