def test_minimal_compatible_input(self):
# Matrices are already in the correct order and have matching IDs.
np.random.seed(0)
# input as DistanceMatrix instances
obs = pwmantel(self.min_dms, alternative="greater")
assert_frame_equal(obs, self.exp_results_minimal)
np.random.seed(0)
# input as array_like
obs = pwmantel((self.minx, self.miny, self.minz), alternative="greater")
assert_frame_equal(obs, self.exp_results_minimal)
def test_minimal_compatible_input(self):
# Matrices are already in the correct order and have matching IDs.
np.random.seed(0)
# input as DistanceMatrix instances
obs = pwmantel(self.min_dms, alternative='greater')
assert_frame_equal(obs, self.exp_results_minimal)
np.random.seed(0)
# input as array_like
obs = pwmantel((self.minx, self.miny, self.minz),
alternative='greater')
assert_frame_equal(obs, self.exp_results_minimal)
def test_strict(self):
# Matrices have some matching and nonmatching IDs, with different
# ordering.
x = self.x_extra.filter(['1', '0', 'foo', '2'])
y = self.miny.filter(['0', '2', '1'])
z = self.z_extra.filter(['bar', '1', '2', '0'])
np.random.seed(0)
# strict=False should discard IDs that aren't found in both matrices
obs = pwmantel((x, y, z), alternative='greater', strict=False)
assert_frame_equal(obs, self.exp_results_reordered_distance_matrices)
with self.assertRaises(ValueError):
pwmantel((x, y, z), strict=True)
def test_minimal_compatible_input_with_labels(self):
np.random.seed(0)
obs = pwmantel(self.min_dms,
alternative='greater',
labels=('minx', 'miny', 'minz'))
assert_frame_equal(obs, self.exp_results_minimal_with_labels)
def test_id_lookup(self):
# Matrices have mismatched IDs but a lookup is provided.
self.minx_dm_extra.ids = ['a', 'b', 'c', 'foo']
self.minz_dm_extra.ids = ['d', 'e', 'f', 'bar']
lookup = {'a': '0', 'b': '1', 'c': '2', 'foo': 'foo',
'd': '0', 'e': '1', 'f': '2', 'bar': 'bar',
'0': '0', '1': '1', '2': '2'}
x = self.minx_dm_extra.filter(['b', 'a', 'foo', 'c'])
y = self.miny_dm.filter(['0', '2', '1'])
z = self.minz_dm_extra.filter(['bar', 'e', 'f', 'd'])
x_copy = x.copy()
y_copy = y.copy()
z_copy = z.copy()
np.random.seed(0)
obs = pwmantel((x, y, z), alternative='greater', strict=False,
lookup=lookup)
assert_frame_equal(obs, self.exp_results_reordered_distance_matrices)
# Make sure the inputs aren't modified.
self.assertEqual(x, x_copy)
self.assertEqual(y, y_copy)
self.assertEqual(z, z_copy)
def test_id_lookup(self):
# Matrices have mismatched IDs but a lookup is provided.
self.minx_dm_extra.ids = ['a', 'b', 'c', 'foo']
self.minz_dm_extra.ids = ['d', 'e', 'f', 'bar']
lookup = {'a': '0', 'b': '1', 'c': '2', 'foo': 'foo',
'd': '0', 'e': '1', 'f': '2', 'bar': 'bar',
'0': '0', '1': '1', '2': '2'}
x = self.minx_dm_extra.filter(['b', 'a', 'foo', 'c'])
y = self.miny_dm.filter(['0', '2', '1'])
z = self.minz_dm_extra.filter(['bar', 'e', 'f', 'd'])
x_copy = x.copy()
y_copy = y.copy()
z_copy = z.copy()
np.random.seed(0)
obs = pwmantel((x, y, z), alternative='greater', strict=False,
lookup=lookup)
assert_data_frame_almost_equal(
obs,
self.exp_results_reordered_distance_matrices)
# Make sure the inputs aren't modified.
self.assertEqual(x, x_copy)
self.assertEqual(y, y_copy)
self.assertEqual(z, z_copy)
def test_id_lookup(self):
# Matrices have mismatched IDs but a lookup is provided.
self.minx_dm_extra.ids = ["a", "b", "c", "foo"]
self.minz_dm_extra.ids = ["d", "e", "f", "bar"]
lookup = {
"a": "0",
"b": "1",
"c": "2",
"foo": "foo",
"d": "0",
"e": "1",
"f": "2",
"bar": "bar",
"0": "0",
"1": "1",
"2": "2",
}
x = self.minx_dm_extra.filter(["b", "a", "foo", "c"])
y = self.miny_dm.filter(["0", "2", "1"])
z = self.minz_dm_extra.filter(["bar", "e", "f", "d"])
x_copy = x.copy()
y_copy = y.copy()
z_copy = z.copy()
np.random.seed(0)
obs = pwmantel((x, y, z), alternative="greater", strict=False, lookup=lookup)
assert_frame_equal(obs, self.exp_results_reordered_distance_matrices)
# Make sure the inputs aren't modified.
self.assertEqual(x, x_copy)
self.assertEqual(y, y_copy)
self.assertEqual(z, z_copy)
def test_minimal_compatible_input_with_labels(self):
np.random.seed(0)
obs = pwmantel(self.min_dms, alternative='greater',
labels=('minx', 'miny', 'minz'))
assert_data_frame_almost_equal(
obs,
self.exp_results_minimal_with_labels)
def test_filepaths_as_input(self):
dms = [
get_data_path('dm.txt'),
get_data_path('dm2.txt'),
]
np.random.seed(0)
obs = pwmantel(dms)
assert_data_frame_almost_equal(obs, self.exp_results_dm_dm2)
def test_filepaths_as_input(self):
dms = [
get_data_path('dm.txt'),
get_data_path('dm2.txt'),
]
np.random.seed(0)
obs = pwmantel(dms)
assert_data_frame_almost_equal(obs, self.exp_results_dm_dm2)
def test_reordered_distance_matrices(self):
# Matrices have matching IDs but they all have different ordering.
x = self.minx_dm.filter(['1', '0', '2'])
y = self.miny_dm.filter(['0', '2', '1'])
z = self.minz_dm.filter(['1', '2', '0'])
np.random.seed(0)
obs = pwmantel((x, y, z), alternative='greater')
assert_frame_equal(obs, self.exp_results_reordered_distance_matrices)
def test_reordered_distance_matrices(self):
# Matrices have matching IDs but they all have different ordering.
x = self.minx.filter(['1', '0', '2'])
y = self.miny.filter(['0', '2', '1'])
z = self.minz.filter(['1', '2', '0'])
np.random.seed(0)
obs = pwmantel((x, y, z), alternative='greater')
assert_frame_equal(obs, self.exp_results_reordered_distance_matrices)
def test_reordered_distance_matrices(self):
# Matrices have matching IDs but they all have different ordering.
x = self.minx_dm.filter(["1", "0", "2"])
y = self.miny_dm.filter(["0", "2", "1"])
z = self.minz_dm.filter(["1", "2", "0"])
np.random.seed(0)
obs = pwmantel((x, y, z), alternative="greater")
assert_frame_equal(obs, self.exp_results_reordered_distance_matrices)
def test_many_filepaths_as_input(self):
dms = [
get_data_path('dm2.txt'),
get_data_path('dm.txt'),
get_data_path('dm4.txt'),
get_data_path('dm3.txt')
]
np.random.seed(0)
obs = pwmantel(dms)
self.assert_pwmantel_almost_equal(obs, self.exp_results_all_dms)
def test_strict(self):
# Matrices have some matching and nonmatching IDs, with different
# ordering.
x = self.minx_dm_extra.filter(['1', '0', 'foo', '2'])
y = self.miny_dm.filter(['0', '2', '1'])
z = self.minz_dm_extra.filter(['bar', '1', '2', '0'])
np.random.seed(0)
# strict=False should discard IDs that aren't found in both matrices
obs = pwmantel((x, y, z), alternative='greater', strict=False)
assert_frame_equal(obs, self.exp_results_reordered_distance_matrices)
def test_strict(self):
# Matrices have some matching and nonmatching IDs, with different
# ordering.
x = self.minx_dm_extra.filter(["1", "0", "foo", "2"])
y = self.miny_dm.filter(["0", "2", "1"])
z = self.minz_dm_extra.filter(["bar", "1", "2", "0"])
np.random.seed(0)
# strict=False should discard IDs that aren't found in both matrices
obs = pwmantel((x, y, z), alternative="greater", strict=False)
assert_frame_equal(obs, self.exp_results_reordered_distance_matrices)
def test_duplicate_labels(self):
with self.assertRaises(ValueError):
pwmantel(self.min_dms, labels=['foo', 'bar', 'foo'])
def test_wrong_number_of_labels(self):
with self.assertRaises(ValueError):
pwmantel(self.min_dms, labels=['foo', 'bar'])
def test_too_few_dms(self):
with self.assertRaises(ValueError):
pwmantel([self.miny_dm])
def test_invalid_input_type(self):
with self.assertRaises(TypeError):
pwmantel([self.miny, self.minx, [[0, 42], [42, 0]]])
def test_na_p_value(self):
obs = pwmantel((self.miny_dm, self.minx_dm), method='spearman',
permutations=0)
assert_frame_equal(obs, self.exp_results_na_p_value)
def test_too_few_dms(self):
with self.assertRaises(ValueError):
pwmantel([self.miny_dm])
def test_many_filepaths_as_input(self):
dms = [get_data_path("dm2.txt"), get_data_path("dm.txt"), get_data_path("dm4.txt"), get_data_path("dm3.txt")]
np.random.seed(0)
obs = pwmantel(dms)
assert_frame_equal(obs, self.exp_results_all_dms)
def test_duplicate_labels(self):
with self.assertRaises(ValueError):
pwmantel(self.min_dms, labels=["foo", "bar", "foo"])
def test_minimal_compatible_input_with_labels(self):
np.random.seed(0)
obs = pwmantel(self.min_dms, alternative="greater", labels=("minx", "miny", "minz"))
assert_frame_equal(obs, self.exp_results_minimal_with_labels)
def test_mixed_input_types(self):
# DistanceMatrix, DistanceMatrix, array_like
with self.assertRaises(TypeError):
pwmantel((self.miny_dm, self.minx_dm, self.minz))
def test_no_matching_ids(self):
self.minx.ids = ['foo', 'bar', 'baz']
self.miny.ids = ['bro', 'fist', 'breh']
with self.assertRaises(ValueError):
pwmantel((self.minx, self.miny, self.minz), strict=False)
def test_duplicate_dms(self):
obs = pwmantel((self.minx_dm, self.minx_dm, self.minx_dm),
alternative='less')
assert_data_frame_almost_equal(obs, self.exp_results_duplicate_dms)
def test_duplicate_dms(self):
obs = pwmantel((self.minx_dm, self.minx_dm, self.minx_dm),
alternative='less')
assert_frame_equal(obs, self.exp_results_duplicate_dms)
def test_na_p_value(self):
obs = pwmantel((self.miny_dm, self.minx_dm), method='spearman',
permutations=0)
assert_data_frame_almost_equal(obs, self.exp_results_na_p_value)
def test_duplicate_labels(self):
with self.assertRaises(ValueError):
pwmantel(self.min_dms, labels=['foo', 'bar', 'foo'])
def test_duplicate_dms(self):
obs = pwmantel((self.minx_dm, self.minx_dm, self.minx_dm), alternative="less")
assert_frame_equal(obs, self.exp_results_duplicate_dms)
def test_too_few_permutations_for_p_value(self):
obs = pwmantel((self.miny, self.minx), method='spearman',
permutations=9)
assert_frame_equal(obs, self.exp_results_too_few_permutations)
def test_missing_ids_in_lookup(self):
# mapping for '1' is missing
lookup = {'0': 'a', '2': 'c'}
with self.assertRaises(KeyError):
pwmantel(self.min_dms, lookup=lookup)
def test_wrong_number_of_labels(self):
with self.assertRaises(ValueError):
pwmantel(self.min_dms, labels=['foo', 'bar'])
def test_too_few_permutations_for_p_value(self):
obs = pwmantel((self.miny_dm, self.minx_dm),
method='spearman',
permutations=9)
assert_frame_equal(obs, self.exp_results_too_few_permutations)
def test_mixed_input_types(self):
# DistanceMatrix, DistanceMatrix, array_like
with self.assertRaises(TypeError):
pwmantel((self.miny_dm, self.minx_dm, self.minz))
def test_minimal_compatible_input(self):
# Matrices are already in the correct order and have matching IDs.
np.random.seed(0)
obs = pwmantel(self.min_dms, alternative='greater')
assert_frame_equal(obs, self.exp_results_minimal)
