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)
