def test_joint_feature_continuous(): # FIXME # first make perfect prediction, including pairwise part X, Y = generate_blocks_multinomial(noise=2, n_samples=1, seed=1) x, y = X[0], Y[0] n_states = x.shape[-1] pw_horz = -1 * np.eye(n_states) xx, yy = np.indices(pw_horz.shape) # linear ordering constraint horizontally pw_horz[xx > yy] = 1 # high cost for unequal labels vertically pw_vert = -1 * np.eye(n_states) pw_vert[xx != yy] = 1 pw_vert *= 10 # create crf, assemble weight, make prediction for inference_method in get_installed(["lp", "ad3"]): crf = DirectionalGridCRF(inference_method=inference_method) crf.initialize(X, Y) w = np.hstack([np.eye(3).ravel(), -pw_horz.ravel(), -pw_vert.ravel()]) y_pred = crf.inference(x, w, relaxed=True) # compute joint_feature for prediction joint_feature_y = crf.joint_feature(x, y_pred) assert_equal(joint_feature_y.shape, (crf.size_joint_feature,))
def test_pickle(): import pickle # classification obj = tree.DecisionTreeClassifier() obj.fit(iris.data, iris.target) score = obj.score(iris.data, iris.target) s = pickle.dumps(obj) obj2 = pickle.loads(s) assert_equal(type(obj2), obj.__class__) score2 = obj2.score(iris.data, iris.target) assert score == score2, "Failed to generate same score " + \ " after pickling (classification) " # regression obj = tree.DecisionTreeRegressor() obj.fit(boston.data, boston.target) score = obj.score(boston.data, boston.target) s = pickle.dumps(obj) obj2 = pickle.loads(s) assert_equal(type(obj2), obj.__class__) score2 = obj2.score(boston.data, boston.target) assert score == score2, "Failed to generate same score " + \ " after pickling (regression) "
def test_read_volume_from_src(): """Test reading volumes from a mixed source space.""" aseg_fname = op.join(subjects_dir, 'sample', 'mri', 'aseg.mgz') labels_vol = ['Left-Amygdala', 'Brain-Stem', 'Right-Amygdala'] src = read_source_spaces(fname) # Setup a volume source space vol_src = setup_volume_source_space('sample', mri=aseg_fname, pos=5.0, bem=fname_bem, volume_label=labels_vol, subjects_dir=subjects_dir) # Generate the mixed source space src += vol_src volume_src = get_volume_labels_from_src(src, 'sample', subjects_dir) volume_label = volume_src[0].name volume_label = 'Left-' + volume_label.replace('-lh', '') # Test assert_equal(volume_label, src[2]['seg_name']) assert_equal(src[2]['type'], 'vol')
def test_read_write_sio(): eg_sio1 = BytesIO() with make_simple(eg_sio1, 'w') as f1: str_val = eg_sio1.getvalue() eg_sio2 = BytesIO(str_val) with netcdf_file(eg_sio2) as f2: check_simple(f2) # Test that error is raised if attempting mmap for sio eg_sio3 = BytesIO(str_val) assert_raises(ValueError, netcdf_file, eg_sio3, 'r', True) # Test 64-bit offset write / read eg_sio_64 = BytesIO() with make_simple(eg_sio_64, 'w', version=2) as f_64: str_val = eg_sio_64.getvalue() eg_sio_64 = BytesIO(str_val) with netcdf_file(eg_sio_64) as f_64: check_simple(f_64) assert_equal(f_64.version_byte, 2) # also when version 2 explicitly specified eg_sio_64 = BytesIO(str_val) with netcdf_file(eg_sio_64, version=2) as f_64: check_simple(f_64) assert_equal(f_64.version_byte, 2)
def test_add_patch_info(): """Test adding patch info to source space.""" # let's setup a small source space src = read_source_spaces(fname_small) src_new = read_source_spaces(fname_small) for s in src_new: s['nearest'] = None s['nearest_dist'] = None s['pinfo'] = None # test that no patch info is added for small dist_limit try: add_source_space_distances(src_new, dist_limit=0.00001) except RuntimeError: # what we throw when scipy version is wrong pass else: assert all(s['nearest'] is None for s in src_new) assert all(s['nearest_dist'] is None for s in src_new) assert all(s['pinfo'] is None for s in src_new) # now let's use one that works add_source_space_distances(src_new) for s1, s2 in zip(src, src_new): assert_array_equal(s1['nearest'], s2['nearest']) assert_allclose(s1['nearest_dist'], s2['nearest_dist'], atol=1e-7) assert_equal(len(s1['pinfo']), len(s2['pinfo'])) for p1, p2 in zip(s1['pinfo'], s2['pinfo']): assert_array_equal(p1, p2)
def test_singletime(self): # issue 215 test (date2index with time variable length == 1) f = Dataset(self.file) time2 = f.variables['time2'] result_index = date2index(self.first_timestamp,time2, select="exact") assert_equal(result_index, 0) f.close()
def test_source_space_from_label(): """Test generating a source space from volume label.""" tempdir = _TempDir() aseg_fname = op.join(subjects_dir, 'sample', 'mri', 'aseg.mgz') label_names = get_volume_labels_from_aseg(aseg_fname) volume_label = label_names[int(np.random.rand() * len(label_names))] # Test pos as dict pos = dict() pytest.raises(ValueError, setup_volume_source_space, 'sample', pos=pos, volume_label=volume_label, mri=aseg_fname) # Test no mri provided pytest.raises(RuntimeError, setup_volume_source_space, 'sample', mri=None, volume_label=volume_label) # Test invalid volume label pytest.raises(ValueError, setup_volume_source_space, 'sample', volume_label='Hello World!', mri=aseg_fname) src = setup_volume_source_space('sample', subjects_dir=subjects_dir, volume_label=volume_label, mri=aseg_fname, add_interpolator=False) assert_equal(volume_label, src[0]['seg_name']) # test reading and writing out_name = op.join(tempdir, 'temp-src.fif') write_source_spaces(out_name, src) src_from_file = read_source_spaces(out_name) _compare_source_spaces(src, src_from_file, mode='approx')
def test_TimeArray_bool(): time1 = ts.TimeArray([1, 2, 3], time_unit="s") time2 = ts.TimeArray([1000, 2000, 3000], time_unit="ms") bool_arr = np.ones(time1.shape, dtype=bool) npt.assert_equal(time1, time2) npt.assert_equal(bool_arr, time1 == time2) nt.assert_not_equal(type(time1 == time2), ts.TimeArray)
def test_UniformTime_preserves_uniformity(): "Uniformity: allow ops which keep it, and deny those which break it" utime = ts.UniformTime(t0=0, length=10, sampling_rate=1) def assign_to_one_element_of(t): t[0] = 42 nt.assert_raises(ValueError, assign_to_one_element_of, utime) # same as utime, but starting 10s later utime10 = ts.UniformTime(t0=10, length=10, sampling_rate=1) utime += 10 # constants treated as having same units as utime npt.assert_equal(utime, utime10) # same as utime, but with a lower sampling rate utime_2 = ts.UniformTime(t0=10, length=10, sampling_interval=2) utime += np.arange(10) # make utime match utime_2 npt.assert_equal(utime, utime_2) npt.assert_equal(utime.sampling_interval, utime_2.sampling_interval) utime = ts.UniformTime(t0=5, length=10, sampling_rate=1) utime *= 2 # alternative way to make utime match utime_2 npt.assert_equal(utime.sampling_interval, utime_2.sampling_interval) npt.assert_equal(utime.sampling_rate, utime_2.sampling_rate) nonuniform = np.concatenate((list(range(2)), list(range(3)), list(range(5)))) def iadd_nonuniform(t): t += nonuniform nt.assert_raises(ValueError, iadd_nonuniform, utime)
def test_save_dict(): # Test that dict can be saved (as recarray), loaded as matstruct dict_types = ((dict, False),) try: from collections import OrderedDict except ImportError: pass else: dict_types += ((OrderedDict, True),) ab_exp = np.array([[(1, 2)]], dtype=[('a', object), ('b', object)]) ba_exp = np.array([[(2, 1)]], dtype=[('b', object), ('a', object)]) for dict_type, is_ordered in dict_types: # Initialize with tuples to keep order for OrderedDict d = dict_type([('a', 1), ('b', 2)]) stream = BytesIO() savemat(stream, {'dict': d}) stream.seek(0) vals = loadmat(stream)['dict'] assert_equal(set(vals.dtype.names), set(['a', 'b'])) if is_ordered: # Input was ordered, output in ab order assert_array_equal(vals, ab_exp) else: # Not ordered input, either order output if vals.dtype.names[0] == 'a': assert_array_equal(vals, ab_exp) else: assert_array_equal(vals, ba_exp)
def test_fieldnames(): # Check that field names are as expected stream = BytesIO() savemat(stream, {'a': {'a':1, 'b':2}}) res = loadmat(stream) field_names = res['a'].dtype.names assert_equal(set(field_names), set(('a', 'b')))
def test_cornercase(self): np.random.seed(1234) # Rounding error may prevent convergence with tol=0 --- ensure # that the return values in this case are correct, and no # exceptions are raised for n in [3, 5, 10, 100]: A = 2*eye(n) b = np.ones(n) x, info = lgmres(A, b, maxiter=10) assert_equal(info, 0) assert_allclose(A.dot(x) - b, 0, atol=1e-14) x, info = lgmres(A, b, tol=0, maxiter=10) if info == 0: assert_allclose(A.dot(x) - b, 0, atol=1e-14) b = np.random.rand(n) x, info = lgmres(A, b, maxiter=10) assert_equal(info, 0) assert_allclose(A.dot(x) - b, 0, atol=1e-14) x, info = lgmres(A, b, tol=0, maxiter=10) if info == 0: assert_allclose(A.dot(x) - b, 0, atol=1e-14)
def test_unicode_mat4(): # Mat4 should save unicode as latin1 bio = BytesIO() var = {'second_cat': u('Schrödinger')} savemat(bio, var, format='4') var_back = loadmat(bio) assert_equal(var_back['second_cat'], var['second_cat'])
def assert_image_equal(actual, expected): if np.issubdtype(actual.dtype, np.integer): assert_equal(actual, expected) else: if np.issubdtype(expected.dtype, np.integer): expected = expected/float(np.iinfo(expected.dtype).max) assert_allclose(actual, expected, atol=1/256.)
def test_nans(self): A = eye(3, format='lil') A[1,1] = np.nan b = np.ones(3) x, info = lgmres(A, b, tol=0, maxiter=10) assert_equal(info, 1)
def test_copy_index_vector(): nobs = 5 k_endog = 3 index = np.zeros((k_endog, nobs)) index[0, 0] = 1 index[:2, 1] = 1 index[0, 2] = 1 index[2, 2] = 1 index[1, 3] = 1 index[2, 4] = 1 A = np.zeros((k_endog, nobs)) for t in range(nobs): for i in range(k_endog): if index[i, t]: A[i, t] = 1. B = np.zeros((k_endog, nobs), order='F') print(A[:, 3]) index = np.asfortranarray(index.astype(np.int32)) tools.copy_index_vector(A, B, index, inplace=True) print(B[:, 3]) assert_equal(B, A)
def test_string_vs_atomgroup_proper(universe, lipid_heads): lfls_ag = LeafletFinder(universe, lipid_heads, pbc=True) lfls_string = LeafletFinder(universe, LIPID_HEAD_STRING, pbc=True) groups_ag = lfls_ag.groups() groups_string = lfls_string.groups() assert_equal(groups_string[0].indices, groups_ag[0].indices) assert_equal(groups_string[1].indices, groups_ag[1].indices)
def test_copy_missing_diagonal_submatrix(): nobs = 5 k_endog = 3 missing = np.zeros((k_endog, nobs)) missing[0, 0] = 1 missing[:2, 1] = 1 missing[0, 2] = 1 missing[2, 2] = 1 missing[1, 3] = 1 missing[2, 4] = 1 A = np.zeros((k_endog, k_endog, nobs)) for t in range(nobs): n = int(k_endog - np.sum(missing[:, t])) A[:n, :n, t] = np.eye(n) B = np.zeros((k_endog, k_endog, nobs), order='F') missing = np.asfortranarray(missing.astype(np.int32)) tools.copy_missing_matrix(A, B, missing, True, True, False, inplace=True) assert_equal(B, A) B = np.zeros((k_endog, k_endog, nobs), order='F') tools.copy_missing_matrix(A, B, missing, True, True, True, inplace=True) assert_equal(B, A)
def test_copy_index_diagonal_submatrix(): nobs = 5 k_endog = 3 index = np.zeros((k_endog, nobs)) index[0, 0] = 1 index[:2, 1] = 1 index[0, 2] = 1 index[2, 2] = 1 index[1, 3] = 1 index[2, 4] = 1 A = np.zeros((k_endog, k_endog, nobs)) for t in range(nobs): for i in range(k_endog): if index[i, t]: A[i, i, t] = 1. B = np.zeros((k_endog, k_endog, nobs), order='F') index = np.asfortranarray(index.astype(np.int32)) tools.copy_index_matrix(A, B, index, True, True, False, inplace=True) assert_equal(B, A) B = np.zeros((k_endog, k_endog, nobs), order='F') tools.copy_index_matrix(A, B, index, True, True, True, inplace=True) assert_equal(B, A)
def test_classification_report(): """Test performance report""" iris = datasets.load_iris() y_true, y_pred, _ = make_prediction(dataset=iris, binary=False) # print classification report with class names expected_report = """\ precision recall f1-score support setosa 0.82 0.92 0.87 25 versicolor 0.56 0.17 0.26 30 virginica 0.47 0.90 0.62 20 avg / total 0.62 0.61 0.56 75 """ report = classification_report( y_true, y_pred, labels=range(len(iris.target_names)), target_names=iris.target_names) assert_equal(report, expected_report) # print classification report with label detection expected_report = """\ precision recall f1-score support 0 0.82 0.92 0.87 25 1 0.56 0.17 0.26 30 2 0.47 0.90 0.62 20 avg / total 0.62 0.61 0.56 75 """ report = classification_report(y_true, y_pred) assert_equal(report, expected_report)
def test_reorder_vector(): nobs = 5 k_endog = 3 missing = np.zeros((k_endog, nobs)) missing[0, 0] = 1 missing[:2, 1] = 1 missing[0, 2] = 1 missing[2, 2] = 1 missing[1, 3] = 1 missing[2, 4] = 1 given = np.zeros((k_endog, nobs)) given[:, :] = np.array([1, 2, 3])[:, np.newaxis] desired = given.copy() given[:, 0] = [2, 3, 0] desired[:, 0] = [0, 2, 3] given[:, 1] = [3, 0, 0] desired[:, 1] = [0, 0, 3] given[:, 2] = [2, 0, 0] desired[:, 2] = [0, 2, 0] given[:, 3] = [1, 3, 0] desired[:, 3] = [1, 0, 3] given[:, 4] = [1, 2, 0] desired[:, 4] = [1, 2, 0] actual = np.asfortranarray(given.copy()) missing = np.asfortranarray(missing.astype(np.int32)) tools.reorder_missing_vector(actual, missing, inplace=True) assert_equal(actual, desired)
def test_length(self): class Foo: def __len__(self): return 10 a= Foo() res = inline_tools.inline('return_val = a.length();',['a']) assert_equal(res,len(a))
def test_anisotropic_power(): for n_coeffs in [6, 15, 28, 45, 66, 91]: for norm_factor in [0.0005, 0.00001]: # Create some really simple cases: coeffs = np.ones((3, n_coeffs)) max_order = calculate_max_order(coeffs.shape[-1]) # For the case where all coeffs == 1, the ap is simply log of the # number of even orders up to the maximal order: analytic = (np.log(len(range(2, max_order + 2, 2))) - np.log(norm_factor)) answers = [analytic] * 3 apvals = anisotropic_power(coeffs, norm_factor=norm_factor) assert_array_almost_equal(apvals, answers) # Test that this works for single voxel arrays as well: assert_array_almost_equal( anisotropic_power(coeffs[1], norm_factor=norm_factor), answers[1]) # Test that even when we look at an all-zeros voxel, this # avoids a log-of-zero warning: with warnings.catch_warnings(record=True) as w: assert_equal(anisotropic_power(np.zeros(6)), 0) assert len(w) == 0
def test_min_signal_default(self): signal, gtab, expected = make_fake_signal() model_default = self.model(gtab, 4) shm_default = model_default.fit(signal).shm_coeff model_correct = self.model(gtab, 4, min_signal=1e-5) shm_correct = model_correct.fit(signal).shm_coeff assert_equal(shm_default, shm_correct)
def test_sph_harm_ind_list(): m_list, n_list = sph_harm_ind_list(8) assert_equal(m_list.shape, n_list.shape) assert_equal(m_list.shape, (45,)) assert_true(np.all(np.abs(m_list) <= n_list)) assert_array_equal(n_list % 2, 0) assert_raises(ValueError, sph_harm_ind_list, 1)
def test_branches(self): with np.errstate(all="ignore"): for t in [np.complex64, np.complex128]: # tupled (numerator, denominator, expected) # for testing as expected == numerator/denominator data = list() # trigger branch: real(fabs(denom)) > imag(fabs(denom)) # followed by else condition as neither are == 0 data.append((( 2.0, 1.0), ( 2.0, 1.0), (1.0, 0.0))) # trigger branch: real(fabs(denom)) > imag(fabs(denom)) # followed by if condition as both are == 0 # is performed in test_zero_division(), so this is skipped # trigger else if branch: real(fabs(denom)) < imag(fabs(denom)) data.append((( 1.0, 2.0), ( 1.0, 2.0), (1.0, 0.0))) for cases in data: n = cases[0] d = cases[1] ex = cases[2] result = t(complex(n[0], n[1])) / t(complex(d[0], d[1])) # check real and imag parts separately to avoid comparison # in array context, which does not account for signed zeros assert_equal(result.real, ex[0]) assert_equal(result.imag, ex[1])
def test_single_voxel_fit(self): signal, gtab, expected = make_fake_signal() sphere = hemi_icosahedron.subdivide(4) model = self.model(gtab, sh_order=4, min_signal=1e-5, assume_normed=True) fit = model.fit(signal) odf = fit.odf(sphere) assert_equal(odf.shape, sphere.phi.shape) directions, _, _ = peak_directions(odf, sphere) # Check the same number of directions n = len(expected) assert_equal(len(directions), n) # Check directions are unit vectors cos_similarity = (directions * directions).sum(-1) assert_array_almost_equal(cos_similarity, np.ones(n)) # Check the directions == expected or -expected cos_similarity = (directions * expected).sum(-1) assert_array_almost_equal(abs(cos_similarity), np.ones(n)) # Test normalize data model = self.model(gtab, sh_order=4, min_signal=1e-5, assume_normed=False) fit = model.fit(signal * 5) odf_with_norm = fit.odf(sphere) assert_array_almost_equal(odf, odf_with_norm)
def test_accumulate_files(self): fnames = ['PLP0000708.nx.hdf', 'PLP0000709.nx.hdf'] pths = [os.path.join(self.path, fname) for fname in fnames] plp.accumulate_HDF_files(pths) f8, f9, fadd = None, None, None try: f8 = h5py.File(os.path.join(self.path, 'PLP0000708.nx.hdf'), 'r') f9 = h5py.File(os.path.join(self.path, 'PLP0000709.nx.hdf'), 'r') fadd = h5py.File(os.path.join(os.getcwd(), 'ADD_PLP0000708.nx.hdf'), 'r') f8d = f8['entry1/data/hmm'][0] f9d = f9['entry1/data/hmm'][0] faddd = fadd['entry1/data/hmm'][0] assert_equal(faddd, f8d + f9d) finally: if f8 is not None: f8.close() if f9 is not None: f9.close() if fadd is not None: fadd.close()
def test_float_modulus_exact(self): # test that float results are exact for small integers. This also # holds for the same integers scaled by powers of two. nlst = list(range(-127, 0)) plst = list(range(1, 128)) dividend = nlst + [0] + plst divisor = nlst + plst arg = list(itertools.product(dividend, divisor)) tgt = list(divmod(*t) for t in arg) a, b = np.array(arg, dtype=int).T # convert exact integer results from Python to float so that # signed zero can be used, it is checked. tgtdiv, tgtrem = np.array(tgt, dtype=float).T tgtdiv = np.where((tgtdiv == 0.0) & ((b < 0) ^ (a < 0)), -0.0, tgtdiv) tgtrem = np.where((tgtrem == 0.0) & (b < 0), -0.0, tgtrem) for dt in np.typecodes['Float']: msg = 'dtype: %s' % (dt,) fa = a.astype(dt) fb = b.astype(dt) # use list comprehension so a_ and b_ are scalars div = [self.floordiv(a_, b_) for a_, b_ in zip(fa, fb)] rem = [self.mod(a_, b_) for a_, b_ in zip(fa, fb)] assert_equal(div, tgtdiv, err_msg=msg) assert_equal(rem, tgtrem, err_msg=msg)
def test_list_refcount(self): a = UserList([1,2,3]) # temporary refcount fix until I understand why it incs by one. inline_tools.inline("a[1] = 1234;",['a']) before1 = sys.getrefcount(a) after1 = sys.getrefcount(a) assert_equal(after1,before1)
def test_cut_tree(): np.random.seed(23) nobs = 50 X = np.random.randn(nobs, 4) Z = scipy.cluster.hierarchy.ward(X) cutree = cut_tree(Z) assert_equal(cutree[:, 0], np.arange(nobs)) assert_equal(cutree[:, -1], np.zeros(nobs)) assert_equal(cutree.max(0), np.arange(nobs - 1, -1, -1)) assert_equal(cutree[:, [-5]], cut_tree(Z, n_clusters=5)) assert_equal(cutree[:, [-5, -10]], cut_tree(Z, n_clusters=[5, 10])) assert_equal(cutree[:, [-10, -5]], cut_tree(Z, n_clusters=[10, 5])) nodes = _order_cluster_tree(Z) heights = np.array([node.dist for node in nodes]) assert_equal(cutree[:, np.searchsorted(heights, [5])], cut_tree(Z, height=5)) assert_equal(cutree[:, np.searchsorted(heights, [5, 10])], cut_tree(Z, height=[5, 10])) assert_equal(cutree[:, np.searchsorted(heights, [10, 5])], cut_tree(Z, height=[10, 5]))
def test_sizeof_fmt(): """Test sizeof_fmt.""" assert_equal(sizeof_fmt(0), '0 bytes') assert_equal(sizeof_fmt(1), '1 byte') assert_equal(sizeof_fmt(1000), '1000 bytes')
def test_sum_squared(): """Test optimized sum of squares.""" X = np.random.RandomState(0).randint(0, 50, (3, 3)) assert_equal(np.sum(X ** 2), sum_squared(X))
def test_logging(): """Test logging (to file).""" pytest.raises(ValueError, set_log_level, 'foo') tempdir = _TempDir() test_name = op.join(tempdir, 'test.log') with open(fname_log, 'r') as old_log_file: # [:-1] used to strip an extra "No baseline correction applied" old_lines = clean_lines(old_log_file.readlines()) old_lines.pop(-1) with open(fname_log_2, 'r') as old_log_file_2: old_lines_2 = clean_lines(old_log_file_2.readlines()) old_lines_2.pop(14) old_lines_2.pop(-1) if op.isfile(test_name): os.remove(test_name) # test it one way (printing default off) set_log_file(test_name) set_log_level('WARNING') # should NOT print evoked = read_evokeds(fname_evoked, condition=1) with open(test_name) as fid: assert (fid.readlines() == []) # should NOT print evoked = read_evokeds(fname_evoked, condition=1, verbose=False) with open(test_name) as fid: assert (fid.readlines() == []) # should NOT print evoked = read_evokeds(fname_evoked, condition=1, verbose='WARNING') with open(test_name) as fid: assert (fid.readlines() == []) # SHOULD print evoked = read_evokeds(fname_evoked, condition=1, verbose=True) with open(test_name, 'r') as new_log_file: new_lines = clean_lines(new_log_file.readlines()) assert_equal(new_lines, old_lines) set_log_file(None) # Need to do this to close the old file os.remove(test_name) # now go the other way (printing default on) set_log_file(test_name) set_log_level('INFO') # should NOT print evoked = read_evokeds(fname_evoked, condition=1, verbose='WARNING') with open(test_name) as fid: assert (fid.readlines() == []) # should NOT print evoked = read_evokeds(fname_evoked, condition=1, verbose=False) with open(test_name) as fid: assert (fid.readlines() == []) # SHOULD print evoked = read_evokeds(fname_evoked, condition=1) with open(test_name, 'r') as new_log_file: new_lines = clean_lines(new_log_file.readlines()) assert_equal(new_lines, old_lines) # check to make sure appending works (and as default, raises a warning) with warnings.catch_warnings(record=True) as w: warnings.simplefilter('always') set_log_file(test_name, overwrite=False) assert_equal(len(w), 0) set_log_file(test_name) assert_equal(len(w), 1) assert ('test_utils.py' in w[0].filename) evoked = read_evokeds(fname_evoked, condition=1) with open(test_name, 'r') as new_log_file: new_lines = clean_lines(new_log_file.readlines()) assert_equal(new_lines, old_lines_2) # make sure overwriting works set_log_file(test_name, overwrite=True) # this line needs to be called to actually do some logging evoked = read_evokeds(fname_evoked, condition=1) del evoked with open(test_name, 'r') as new_log_file: new_lines = clean_lines(new_log_file.readlines()) assert_equal(new_lines, old_lines)
def test_hash(): """Test dictionary hashing and comparison functions.""" # does hashing all of these types work: # {dict, list, tuple, ndarray, str, float, int, None} d0 = dict(a=dict(a=0.1, b='fo', c=1), b=[1, 'b'], c=(), d=np.ones(3), e=None) d0[1] = None d0[2.] = b'123' d1 = deepcopy(d0) assert (len(object_diff(d0, d1)) == 0) assert (len(object_diff(d1, d0)) == 0) assert_equal(object_hash(d0), object_hash(d1)) # change values slightly d1['data'] = np.ones(3, int) d1['d'][0] = 0 assert object_hash(d0) != object_hash(d1) d1 = deepcopy(d0) assert_equal(object_hash(d0), object_hash(d1)) d1['a']['a'] = 0.11 assert (len(object_diff(d0, d1)) > 0) assert (len(object_diff(d1, d0)) > 0) assert object_hash(d0) != object_hash(d1) d1 = deepcopy(d0) assert_equal(object_hash(d0), object_hash(d1)) d1['a']['d'] = 0 # non-existent key assert (len(object_diff(d0, d1)) > 0) assert (len(object_diff(d1, d0)) > 0) assert object_hash(d0) != object_hash(d1) d1 = deepcopy(d0) assert_equal(object_hash(d0), object_hash(d1)) d1['b'].append(0) # different-length lists assert (len(object_diff(d0, d1)) > 0) assert (len(object_diff(d1, d0)) > 0) assert object_hash(d0) != object_hash(d1) d1 = deepcopy(d0) assert_equal(object_hash(d0), object_hash(d1)) d1['e'] = 'foo' # non-None assert (len(object_diff(d0, d1)) > 0) assert (len(object_diff(d1, d0)) > 0) assert object_hash(d0) != object_hash(d1) d1 = deepcopy(d0) d2 = deepcopy(d0) d1['e'] = StringIO() d2['e'] = StringIO() d2['e'].write('foo') assert (len(object_diff(d0, d1)) > 0) assert (len(object_diff(d1, d0)) > 0) d1 = deepcopy(d0) d1[1] = 2 assert (len(object_diff(d0, d1)) > 0) assert (len(object_diff(d1, d0)) > 0) assert object_hash(d0) != object_hash(d1) # generators (and other types) not supported d1 = deepcopy(d0) d2 = deepcopy(d0) d1[1] = (x for x in d0) d2[1] = (x for x in d0) pytest.raises(RuntimeError, object_diff, d1, d2) pytest.raises(RuntimeError, object_hash, d1) x = sparse.eye(2, 2, format='csc') y = sparse.eye(2, 2, format='csr') assert ('type mismatch' in object_diff(x, y)) y = sparse.eye(2, 2, format='csc') assert_equal(len(object_diff(x, y)), 0) y[1, 1] = 2 assert ('elements' in object_diff(x, y)) y = sparse.eye(3, 3, format='csc') assert ('shape' in object_diff(x, y)) y = 0 assert ('type mismatch' in object_diff(x, y)) # smoke test for gh-4796 assert object_hash(np.int64(1)) != 0 assert object_hash(np.bool_(True)) != 0
def test_endog(self): npt.assert_equal(self.model.endog, self.data.endog)
def test_design(self): npt.assert_equal(self.model.exog, add_constant(self.data.exog, prepend=True))
def test_dendrogram_single_linkage_tdist(self): # Tests dendrogram calculation on single linkage of the tdist data set. Z = linkage(hierarchy_test_data.ytdist, 'single') R = dendrogram(Z, no_plot=True) leaves = R["leaves"] assert_equal(leaves, [2, 5, 1, 0, 3, 4])
def test_is_monotonic_tdist_linkage2(self): # Tests is_monotonic(Z) on clustering generated by single linkage on # tdist data set. Perturbing. Expecting False. Z = linkage(hierarchy_test_data.ytdist, 'single') Z[2,2] = 0.0 assert_equal(is_monotonic(Z), False)
def check_dendrogram_plot(self, orientation): # Tests dendrogram plotting. Z = linkage(hierarchy_test_data.ytdist, 'single') expected = {'color_list': ['g', 'b', 'b', 'b', 'b'], 'dcoord': [[0.0, 138.0, 138.0, 0.0], [0.0, 219.0, 219.0, 0.0], [0.0, 255.0, 255.0, 219.0], [0.0, 268.0, 268.0, 255.0], [138.0, 295.0, 295.0, 268.0]], 'icoord': [[5.0, 5.0, 15.0, 15.0], [45.0, 45.0, 55.0, 55.0], [35.0, 35.0, 50.0, 50.0], [25.0, 25.0, 42.5, 42.5], [10.0, 10.0, 33.75, 33.75]], 'ivl': ['2', '5', '1', '0', '3', '4'], 'leaves': [2, 5, 1, 0, 3, 4]} fig = plt.figure() ax = fig.add_subplot(221) # test that dendrogram accepts ax keyword R1 = dendrogram(Z, ax=ax, orientation=orientation) assert_equal(R1, expected) # test that dendrogram accepts and handle the leaf_font_size and # leaf_rotation keywords R1a = dendrogram(Z, ax=ax, orientation=orientation, leaf_font_size=20, leaf_rotation=90) testlabel = ( ax.get_xticklabels()[0] if orientation in ['top', 'bottom'] else ax.get_yticklabels()[0] ) assert_equal(testlabel.get_rotation(), 90) assert_equal(testlabel.get_size(), 20) R1a = dendrogram(Z, ax=ax, orientation=orientation, leaf_rotation=90) testlabel = ( ax.get_xticklabels()[0] if orientation in ['top', 'bottom'] else ax.get_yticklabels()[0] ) assert_equal(testlabel.get_rotation(), 90) R1a = dendrogram(Z, ax=ax, orientation=orientation, leaf_font_size=20) testlabel = ( ax.get_xticklabels()[0] if orientation in ['top', 'bottom'] else ax.get_yticklabels()[0] ) assert_equal(testlabel.get_size(), 20) plt.close() # test plotting to gca (will import pylab) R2 = dendrogram(Z, orientation=orientation) plt.close() assert_equal(R2, expected)
def test_is_monotonic_3x4_F3(self): # Tests is_monotonic(Z) on 3x4 linkage (case 3). Expecting False Z = np.asarray([[0, 1, 0.3, 2], [2, 3, 0.4, 2], [4, 5, 0.2, 4]], dtype=np.double) assert_equal(is_monotonic(Z), False)
def test_is_monotonic_Q_linkage(self): # Tests is_monotonic(Z) on clustering generated by single linkage on # Q data set. Expecting True. X = hierarchy_test_data.Q_X Z = linkage(X, 'single') assert_equal(is_monotonic(Z), True)
def test_is_monotonic_2x4_F(self): # Tests is_monotonic(Z) on 2x4 linkage. Expecting False. Z = np.asarray([[0, 1, 0.4, 2], [2, 3, 0.3, 3]], dtype=np.double) assert_equal(is_monotonic(Z), False)
def test_is_monotonic_tdist_linkage1(self): # Tests is_monotonic(Z) on clustering generated by single linkage on # tdist data set. Expecting True. Z = linkage(hierarchy_test_data.ytdist, 'single') assert_equal(is_monotonic(Z), True)
def check_leaves_list_Q(self, method): # Tests leaves_list(Z) on the Q data set X = hierarchy_test_data.Q_X Z = linkage(X, method) node = to_tree(Z) assert_equal(node.pre_order(), leaves_list(Z))
def test_is_monotonic_3x4_T(self): # Tests is_monotonic(Z) on 3x4 linkage. Expecting True. Z = np.asarray([[0, 1, 0.3, 2], [2, 3, 0.4, 2], [4, 5, 0.6, 4]], dtype=np.double) assert_equal(is_monotonic(Z), True)
def test_num_obs_linkage_2x4(self): # Tests num_obs_linkage(Z) on linkage over 3 observations. Z = np.asarray([[0, 1, 3.0, 2], [3, 2, 4.0, 3]], dtype=np.double) assert_equal(num_obs_linkage(Z), 3)
def test_is_monotonic_1x4(self): # Tests is_monotonic(Z) on 1x4 linkage. Expecting True. Z = np.asarray([[0, 1, 0.3, 2]], dtype=np.double) assert_equal(is_monotonic(Z), True)
def test_mlab_linkage_conversion_single_row(self): # Tests from/to_mlab_linkage on linkage array with single row. Z = np.asarray([[0., 1., 3., 2.]]) Zm = [[1, 2, 3]] assert_equal(from_mlab_linkage(Zm), Z) assert_equal(to_mlab_linkage(Z), Zm)
def test_leaves_list_2x4(self): # Tests leaves_list(Z) on a 2x4 linkage. Z = np.asarray([[0, 1, 3.0, 2], [3, 2, 4.0, 3]], dtype=np.double) to_tree(Z) assert_equal(leaves_list(Z), [0, 1, 2])
def test_Heap(): values = np.array([2, -1, 0, -1.5, 3]) heap = Heap(values) pair = heap.get_min() assert_equal(pair['key'], 3) assert_equal(pair['value'], -1.5) heap.remove_min() pair = heap.get_min() assert_equal(pair['key'], 1) assert_equal(pair['value'], -1) heap.change_value(1, 2.5) pair = heap.get_min() assert_equal(pair['key'], 2) assert_equal(pair['value'], 0) heap.remove_min() heap.remove_min() heap.change_value(1, 10) pair = heap.get_min() assert_equal(pair['key'], 4) assert_equal(pair['value'], 3) heap.remove_min() pair = heap.get_min() assert_equal(pair['key'], 1) assert_equal(pair['value'], 10)
def test_num_obs_linkage_1x4(self): # Tests num_obs_linkage(Z) on linkage over 2 observations. Z = np.asarray([[0, 1, 3.0, 2]], dtype=np.double) assert_equal(num_obs_linkage(Z), 2)
def test_min_argmin_basic(x, expected): m, argm = min_argmin(x) assert_equal(m, expected[0]) assert_equal(argm, expected[1])
def test_mlab_linkage_conversion_empty(self): # Tests from/to_mlab_linkage on empty linkage array. X = np.asarray([]) assert_equal(from_mlab_linkage([]), X) assert_equal(to_mlab_linkage([]), X)
def test_argmax_basic(dtype, axis): x = np.array([[11, 10, 10, 23, 31], [19, 20, 21, 22, 23]], dtype=dtype) i = argmax(x, axis=axis) assert_equal(i, np.argmax(x, axis=axis))
def test_max_argmax_basic(x, expected): m, argm = max_argmax(x) assert_equal(m, expected[0]) assert_equal(argm, expected[1])
def test_dtypes(self): # Test with different data types for dtype in [ np.int16, np.uint16, np.int32, np.uint32, np.int64, np.uint64 ]: coords = np.array([[1, 0, 1, 2, 3, 4], [1, 6, 1, 3, 2, 0]], dtype=dtype) shape = (5, 8) uncoords = 8 * coords[0] + coords[1] assert_equal(np.ravel_multi_index(coords, shape), uncoords) assert_equal(coords, np.unravel_index(uncoords, shape)) uncoords = coords[0] + 5 * coords[1] assert_equal(np.ravel_multi_index(coords, shape, order='F'), uncoords) assert_equal(coords, np.unravel_index(uncoords, shape, order='F')) coords = np.array( [[1, 0, 1, 2, 3, 4], [1, 6, 1, 3, 2, 0], [1, 3, 1, 0, 9, 5]], dtype=dtype) shape = (5, 8, 10) uncoords = 10 * (8 * coords[0] + coords[1]) + coords[2] assert_equal(np.ravel_multi_index(coords, shape), uncoords) assert_equal(coords, np.unravel_index(uncoords, shape)) uncoords = coords[0] + 5 * (coords[1] + 8 * coords[2]) assert_equal(np.ravel_multi_index(coords, shape, order='F'), uncoords) assert_equal(coords, np.unravel_index(uncoords, shape, order='F'))
def test_minmax_basic(x, expected): mm = minmax(x) assert_equal(mm, expected)
def test_operate_4d_array(self): a = np.zeros((3, 3, 3, 3), int) fill_diagonal(a, 4) i = np.array([0, 1, 2]) assert_equal(np.where(a != 0), (i, i, i, i))
def test_get_wl_band(drizzle_source_file): obj = drizzle.DrizzleSource(drizzle_source_file) expected = "35" testing.assert_equal(obj._get_wl_band(), expected)