def test_time_delay():
    """Test that time-delaying w/ times and samples works properly."""
    from scipy.sparse import csr_matrix

    # Explicit delays + sfreq
    X = rng.randn(2, 1000)
    X_sp = np.zeros([2, 10])
    X_sp[0, 1] = 1
    X_sp = csr_matrix(X_sp)
    test_tlims = [((0, 2), 1), ((0, .2), 10), ((-.1, .1), 10)]
    for (tmin, tmax), isfreq in test_tlims:
        # sfreq must be int/float
        assert_raises(ValueError, _delay_time_series, X, tmin, tmax,
                      sfreq=[1])
        # Delays must be int/float
        assert_raises(ValueError, _delay_time_series, X,
                      np.complex(tmin), tmax, 1)
        # Make sure swapaxes works
        delayed = _delay_time_series(X, tmin, tmax, isfreq,
                                     newaxis=2, axis=-1)
        assert_equal(delayed.shape[2], 3)
        # Make sure delay slice is correct
        delays = _times_to_delays(tmin, tmax, isfreq)
        keep = _delays_to_slice(delays)
        assert_true(delayed[..., keep].shape[-1] > 0)
        assert_true(np.isnan(delayed[..., keep]).sum() == 0)

        for idata in [X, X_sp]:
            if tmin < 0:
                continue
            X_delayed = _delay_time_series(X, tmin, tmax, isfreq, axis=-1)
            assert_array_equal(X_delayed[0], X)
            assert_array_equal(X_delayed[1][0, :-1], X[0, 1:])
            assert_equal(len(X_delayed), (tmax - tmin) * isfreq + 1)
def test_time_delay():
    """Test that time-delaying w/ times and samples works properly."""
    # Explicit delays + sfreq
    X = np.random.RandomState(0).randn(1000, 2)
    assert (X == 0).sum() == 0  # need this for later
    test_tlims = [
        ((1, 2), 1),
        ((1, 1), 1),
        ((0, 2), 1),
        ((0, 1), 1),
        ((0, 0), 1),
        ((-1, 2), 1),
        ((-1, 1), 1),
        ((-1, 0), 1),
        ((-1, -1), 1),
        ((-2, 2), 1),
        ((-2, 1), 1),
        ((-2, 0), 1),
        ((-2, -1), 1),
        ((-2, -1), 1),
        ((0, .2), 10),
        ((-.1, .1), 10)]
    for (tmin, tmax), isfreq in test_tlims:
        # sfreq must be int/float
        with pytest.raises(TypeError, match='`sfreq` must be an instance of'):
            _delay_time_series(X, tmin, tmax, sfreq=[1])
        # Delays must be int/float
        with pytest.raises(TypeError, match='.*complex.*'):
            _delay_time_series(X, np.complex(tmin), tmax, 1)
        # Make sure swapaxes works
        start, stop = int(round(tmin * isfreq)), int(round(tmax * isfreq)) + 1
        n_delays = stop - start
        X_delayed = _delay_time_series(X, tmin, tmax, isfreq)
        assert_equal(X_delayed.shape, (1000, 2, n_delays))
        # Make sure delay slice is correct
        delays = _times_to_delays(tmin, tmax, isfreq)
        assert_array_equal(delays, np.arange(start, stop))
        keep = _delays_to_slice(delays)
        expected = np.where((X_delayed != 0).all(-1).all(-1))[0]
        got = np.arange(len(X_delayed))[keep]
        assert_array_equal(got, expected)
        assert X_delayed[keep].shape[-1] > 0
        assert (X_delayed[keep] == 0).sum() == 0

        del_zero = int(round(-tmin * isfreq))
        for ii in range(-2, 3):
            idx = del_zero + ii
            err_msg = '[%s,%s] (%s): %s %s' % (tmin, tmax, isfreq, ii, idx)
            if 0 <= idx < X_delayed.shape[-1]:
                if ii == 0:
                    assert_array_equal(X_delayed[:, :, idx], X,
                                       err_msg=err_msg)
                elif ii < 0:  # negative delay
                    assert_array_equal(X_delayed[:ii, :, idx], X[-ii:, :],
                                       err_msg=err_msg)
                    assert_array_equal(X_delayed[ii:, :, idx], 0.)
                else:
                    assert_array_equal(X_delayed[ii:, :, idx], X[:-ii, :],
                                       err_msg=err_msg)
                    assert_array_equal(X_delayed[:ii, :, idx], 0.)
示例#3
0
def test_time_delay():
    """Test that time-delaying w/ times and samples works properly."""
    # Explicit delays + sfreq
    X = np.random.RandomState(0).randn(1000, 2)
    assert (X == 0).sum() == 0  # need this for later
    test_tlims = [
        ((1, 2), 1),
        ((1, 1), 1),
        ((0, 2), 1),
        ((0, 1), 1),
        ((0, 0), 1),
        ((-1, 2), 1),
        ((-1, 1), 1),
        ((-1, 0), 1),
        ((-1, -1), 1),
        ((-2, 2), 1),
        ((-2, 1), 1),
        ((-2, 0), 1),
        ((-2, -1), 1),
        ((-2, -1), 1),
        ((0, .2), 10),
        ((-.1, .1), 10)]
    for (tmin, tmax), isfreq in test_tlims:
        # sfreq must be int/float
        with pytest.raises(TypeError, match='`sfreq` must be an instance of'):
            _delay_time_series(X, tmin, tmax, sfreq=[1])
        # Delays must be int/float
        with pytest.raises(TypeError, match='.*complex.*'):
            _delay_time_series(X, np.complex128(tmin), tmax, 1)
        # Make sure swapaxes works
        start, stop = int(round(tmin * isfreq)), int(round(tmax * isfreq)) + 1
        n_delays = stop - start
        X_delayed = _delay_time_series(X, tmin, tmax, isfreq)
        assert_equal(X_delayed.shape, (1000, 2, n_delays))
        # Make sure delay slice is correct
        delays = _times_to_delays(tmin, tmax, isfreq)
        assert_array_equal(delays, np.arange(start, stop))
        keep = _delays_to_slice(delays)
        expected = np.where((X_delayed != 0).all(-1).all(-1))[0]
        got = np.arange(len(X_delayed))[keep]
        assert_array_equal(got, expected)
        assert X_delayed[keep].shape[-1] > 0
        assert (X_delayed[keep] == 0).sum() == 0

        del_zero = int(round(-tmin * isfreq))
        for ii in range(-2, 3):
            idx = del_zero + ii
            err_msg = '[%s,%s] (%s): %s %s' % (tmin, tmax, isfreq, ii, idx)
            if 0 <= idx < X_delayed.shape[-1]:
                if ii == 0:
                    assert_array_equal(X_delayed[:, :, idx], X,
                                       err_msg=err_msg)
                elif ii < 0:  # negative delay
                    assert_array_equal(X_delayed[:ii, :, idx], X[-ii:, :],
                                       err_msg=err_msg)
                    assert_array_equal(X_delayed[ii:, :, idx], 0.)
                else:
                    assert_array_equal(X_delayed[ii:, :, idx], X[:-ii, :],
                                       err_msg=err_msg)
                    assert_array_equal(X_delayed[:ii, :, idx], 0.)
def test_time_delay():
    """Test that time-delaying w/ times and samples works properly."""
    from scipy.sparse import csr_matrix

    # Explicit delays + sfreq
    X = rng.randn(2, 1000)
    X_sp = np.zeros([2, 10])
    X_sp[0, 1] = 1
    X_sp = csr_matrix(X_sp)
    test_tlims = [((0, 2), 1), ((0, .2), 10), ((-.1, .1), 10)]
    for (tmin, tmax), isfreq in test_tlims:
        # sfreq must be int/float
        assert_raises(ValueError, _delay_time_series, X, tmin, tmax, sfreq=[1])
        # Delays must be int/float
        assert_raises(ValueError, _delay_time_series, X, np.complex(tmin),
                      tmax, 1)
        # Make sure swapaxes works
        delayed = _delay_time_series(X, tmin, tmax, isfreq, newaxis=2, axis=-1)
        assert_equal(delayed.shape[2], 3)
        # Make sure delay slice is correct
        delays = _times_to_delays(tmin, tmax, isfreq)
        keep = _delays_to_slice(delays)
        assert_true(delayed[..., keep].shape[-1] > 0)
        assert_true(np.isnan(delayed[..., keep]).sum() == 0)

        for idata in [X, X_sp]:
            if tmin < 0:
                continue
            X_delayed = _delay_time_series(X, tmin, tmax, isfreq, axis=-1)
            assert_array_equal(X_delayed[0], X)
            assert_array_equal(X_delayed[1][0, :-1], X[0, 1:])
            assert_equal(len(X_delayed), (tmax - tmin) * isfreq + 1)