def _compare_values(v, v2): if isinstance(v, np.ndarray): assert_array_equal(v, v2) elif isinstance(v, dict): for key, value in v.items(): _compare_values(v[key], v2[key]) elif isinstance(v, np.random.RandomState): for s, s2 in zip(v.get_state(), v2.get_state()): _compare_values(s, s2) else: assert_equal(v, v2)
def test_mask_iterator(): # Test the mask iterator length and the shape of the elements fs = 200. tmin, tmax = -0.05, 0.2 n_points = 200 events = np.arange(0, n_points, int(fs * 0.3)) masks = MaskIterator(events, tmin, tmax, n_points, fs) masks_list = [m for m in masks] # test that the length is correct n_masks_0 = len(masks) n_masks_1 = len(masks_list) assert_equal(n_masks_0, n_masks_1) # test that the masks are of the correct shape for mask in masks_list: assert_array_equal(mask.shape, (1, n_points))
def test_raw_to_mask_no_events(): # test that no events gives masks entirely False raw = create_empty_raw() low_sig, high_sig, mask = raw_to_mask(raw, ixs=0, events=None, tmin=None, tmax=None) for one_mask in mask: assert_true(np.all(~one_mask)) # test with no events and tmin, tmax tmin, tmax = 0.2, 0.6 low_sig, high_sig, mask = raw_to_mask(raw, ixs=0, events=None, tmin=tmin, tmax=tmax) for one_mask in mask: assert_equal(one_mask[~one_mask].size, int((tmax - tmin) * raw.info['sfreq']))
def test_degrees_of_freedom(): # test the number of fitted parameters in the model model_params = {'ordar': 5, 'ordriv': 2, 'criterion': False} dar = fast_fitted_model(model_params=model_params) assert_equal(dar.degrees_of_freedom(), 6 * 6) model_params = {'ordar': 5, 'ordriv': 0, 'criterion': False} dar = fast_fitted_model(model_params=model_params) assert_equal(dar.degrees_of_freedom(), 6 * 1) model_params = {'ordar': 1, 'ordriv': 2, 'criterion': False} dar = fast_fitted_model(model_params=model_params) assert_equal(dar.degrees_of_freedom(), 2 * 6) model_params = {'ordar': 10, 'ordriv': 2, 'criterion': False} ar = fast_fitted_model(AR, model_params=model_params) assert_equal(ar.degrees_of_freedom(), 10 + 1) model_params = {'ordar': 10, 'ordriv': 2, 'criterion': False} har = fast_fitted_model(HAR, model_params=model_params) assert_equal(har.degrees_of_freedom(), 10 + 6)
def test_peak_locking_shape(): percentiles = [5, 25, 50, 75, 95] plkg = PeakLocking(fs=fs, low_fq=low_fq, high_fq_range=high_fq_range, percentiles=percentiles) plkg.fit(signal) n_high, n_window = plkg.time_frequency_.shape n_percentiles, n_window_2 = plkg.time_average_.shape assert_equal(n_high, len(high_fq_range)) assert_equal(n_percentiles, len(percentiles)) assert_equal(n_window, n_window_2)
def test_comod_correct_maximum(): # Test that the PAC is maximum at the correct location in the comodulogram for method in ALL_PAC_METRICS: est = ComodTest(method=method, progress_bar=True).fit(signal) comod = est.comod_ # test the shape of the comodulogram assert_array_equal(comod.shape, (n_low, n_high)) # the bicoherence metrics fail this test with current parameters if method in BICOHERENCE_PAC_METRICS or method == 'jiang': continue low_fq_0, high_fq_0, max_pac = est.get_maximum_pac() assert_equal(low_fq_0, low_fq) assert_equal(high_fq_0, high_fq) assert_equal(max_pac, comod.max()) assert_true(np.all(comod > 0))
def test_mask_iterator_length(): # Test the mask iterator length rng = np.random.RandomState(0) fs = 200. n_points = 200 tmin, tmax = -0.05, 0.2 events = np.arange(0, n_points, int(fs * 0.3)) masks = MaskIterator(events, tmin, tmax, n_points, fs) assert_equal(len(masks), 1) tmin, tmax = [-0.05, -0.02, 0], [-0.2, -0.2, 0.1] events = np.arange(0, n_points, int(fs * 0.3)) masks = MaskIterator(events, tmin, tmax, n_points, fs) assert_equal(len(masks), len(tmin)) n_kinds = 3 tmin, tmax = -0.05, 0.2 events = np.arange(0, n_points, 10) events = np.vstack([events, rng.randint(n_kinds, size=len(events))]).T masks = MaskIterator(events, tmin, tmax, n_points, fs) assert_equal(len(masks), n_kinds)
def test_fake_delayed(): # Test that fake_delayed does nothing but returning the input arg assert_equal(twice, _fake_delayed(twice)) assert_equal(42, _fake_delayed(42))
def test_delay_shape(): est = fast_delay() assert_equal(est.neg_log_likelihood_.shape, est.delays_ms_.shape) assert_greater(est.neg_log_likelihood_.shape[0], 1) i_best = np.nanargmin(est.neg_log_likelihood_) assert_equal(est.best_delay_ms_, est.delays_ms_[i_best])
def test_prime_factors(): # Test that the prime factor decomposition products to the input integer for n in range(3, 200, 2): factors = prime_factors(n) assert_equal(np.product(factors), n)
def test_argmax_2d(): # Test that argmax_2d gives the correct indices of the max rng = np.random.RandomState(0) a = rng.randn(4, 3) i, j = argmax_2d(a) assert_equal(a[i, j], a.max())
def test_correct_size(): # Test that the signals are 1D and with the correct number of points for n_points_in in np.int_(np.logspace(1, 3, 5)): signal = simulate_pac_default(n_points=n_points_in) assert_equal(signal.size, n_points_in) assert_equal(signal.ndim, 1)