def test_comparing_same_matrices(self):
for method in self.methods:
obs = mantel(self.minx, self.minx, method=method)[0]
self.assertAlmostEqual(obs, 1)
obs = mantel(self.miny, self.miny, method=method)[0]
self.assertAlmostEqual(obs, 1)
def test_comparing_same_matrices(self):
for method in self.methods:
obs = mantel(self.minx, self.minx, method=method)[0]
self.assertAlmostEqual(obs, 1)
obs = mantel(self.miny, self.miny, method=method)[0]
self.assertAlmostEqual(obs, 1)
def test_invalid_distance_matrix(self):
# Single asymmetric, non-hollow distance matrix.
with self.assertRaises(DissimilarityMatrixError):
mantel([[1, 2], [3, 4]], [[0, 0], [0, 0]])
# Two asymmetric distance matrices.
with self.assertRaises(DistanceMatrixError):
mantel([[0, 2], [3, 0]], [[0, 1], [0, 0]])
def test_invalid_distance_matrix(self):
# Single asymmetric, non-hollow distance matrix.
with self.assertRaises(DissimilarityMatrixError):
mantel([[1, 2], [3, 4]], [[0, 0], [0, 0]])
# Two asymmetric distance matrices.
with self.assertRaises(DistanceMatrixError):
mantel([[0, 2], [3, 0]], [[0, 1], [0, 0]])
def test_one_sided_greater(self):
np.random.seed(0)
obs = mantel(self.minx, self.miny, alternative='greater')
self.assertAlmostEqual(obs[0], self.exp_x_vs_y)
self.assertAlmostEqual(obs[1], 0.324)
obs = mantel(self.minx, self.minx, alternative='greater')
self.assertAlmostEqual(obs[0], 1)
self.assertAlmostEqual(obs[1], 0.172)
def test_one_sided_greater(self):
np.random.seed(0)
obs = mantel(self.minx, self.miny, alternative='greater')
self.assertAlmostEqual(obs[0], self.exp_x_vs_y)
self.assertAlmostEqual(obs[1], 0.324)
obs = mantel(self.minx, self.minx, alternative='greater')
self.assertAlmostEqual(obs[0], 1)
self.assertAlmostEqual(obs[1], 0.172)
def test_no_side_effects(self):
minx = np.asarray(self.minx, dtype='float')
miny = np.asarray(self.miny, dtype='float')
minx_copy = np.copy(minx)
miny_copy = np.copy(miny)
mantel(minx, miny)
# Make sure we haven't modified the input.
npt.assert_equal(minx, minx_copy)
npt.assert_equal(miny, miny_copy)
def test_no_side_effects(self):
minx = np.asarray(self.minx, dtype='float')
miny = np.asarray(self.miny, dtype='float')
minx_copy = np.copy(minx)
miny_copy = np.copy(miny)
mantel(minx, miny)
# Make sure we haven't modified the input.
npt.assert_equal(minx, minx_copy)
npt.assert_equal(miny, miny_copy)
def test_zero_permutations(self):
for alt in self.alternatives:
for method, exp in (('pearson', self.exp_x_vs_y),
('spearman', 0.5)):
obs = mantel(self.minx, self.miny, permutations=0,
method=method, alternative=alt)
self.assertAlmostEqual(obs[0], exp)
npt.assert_equal(obs[1], np.nan)
# swapping order of matrices should give same result
obs = mantel(self.miny, self.minx, permutations=0,
method=method, alternative=alt)
self.assertAlmostEqual(obs[0], exp)
npt.assert_equal(obs[1], np.nan)
def test_vegan_example(self):
np.random.seed(0)
# pearson
obs = mantel(self.veg_dm_vegan, self.env_dm_vegan,
alternative='greater')
self.assertAlmostEqual(obs[0], 0.3047454)
self.assertAlmostEqual(obs[1], 0.002)
# spearman
obs = mantel(self.veg_dm_vegan, self.env_dm_vegan,
alternative='greater', method='spearman')
self.assertAlmostEqual(obs[0], 0.283791)
self.assertAlmostEqual(obs[1], 0.003)
def test_no_variation_spearman(self):
exp = (np.nan, np.nan)
for alt in self.alternatives:
obs = mantel(self.miny, self.no_variation, method='spearman',
alternative=alt)
npt.assert_equal(obs, exp)
obs = mantel(self.no_variation, self.miny, method='spearman',
alternative=alt)
npt.assert_equal(obs, exp)
obs = mantel(self.no_variation, self.no_variation,
method='spearman', alternative=alt)
npt.assert_equal(obs, exp)
def test_vegan_example(self):
np.random.seed(0)
# pearson
obs = mantel(self.veg_dm_vegan,
self.env_dm_vegan,
alternative='greater')
self.assertAlmostEqual(obs[0], 0.3047454)
self.assertAlmostEqual(obs[1], 0.002)
# spearman
obs = mantel(self.veg_dm_vegan,
self.env_dm_vegan,
alternative='greater',
method='spearman')
self.assertAlmostEqual(obs[0], 0.283791)
self.assertAlmostEqual(obs[1], 0.003)
def test_one_sided_less(self):
# no need to seed here as permuted test statistics will all be less
# than or equal to the observed test statistic (1.0)
for method in self.methods:
obs = mantel(self.minx, self.minx, method=method,
alternative='less')
self.assertEqual(obs, (1, 1))
np.random.seed(0)
obs = mantel(self.minx, self.miny, alternative='less')
self.assertAlmostEqual(obs[0], self.exp_x_vs_y)
self.assertAlmostEqual(obs[1], 0.843)
obs = mantel(self.minx, self.minz, alternative='less')
self.assertAlmostEqual(obs[0], self.exp_x_vs_z)
self.assertAlmostEqual(obs[1], 0.172)
def test_two_sided(self):
np.random.seed(0)
obs = mantel(self.minx, self.minx, method='spearman',
alternative='two-sided')
self.assertEqual(obs[0], 1)
self.assertAlmostEqual(obs[1], 0.328)
obs = mantel(self.minx, self.miny, method='spearman',
alternative='two-sided')
self.assertAlmostEqual(obs[0], 0.5)
self.assertAlmostEqual(obs[1], 1.0)
obs = mantel(self.minx, self.minz, method='spearman',
alternative='two-sided')
self.assertAlmostEqual(obs[0], -1)
self.assertAlmostEqual(obs[1], 0.322)
def test_no_variation_pearson(self):
# Output doesn't match vegan::mantel with method='pearson'. Consider
# revising output and this test depending on outcome of
# https://github.com/scipy/scipy/issues/3728
for alt in self.alternatives:
# test one or both inputs having no variation in their
# distances
obs = mantel(self.miny, self.no_variation, method='pearson',
alternative=alt)
npt.assert_equal(obs, (0.0, 1.0))
obs = mantel(self.no_variation, self.miny, method='pearson',
alternative=alt)
npt.assert_equal(obs, (0.0, 1.0))
obs = mantel(self.no_variation, self.no_variation,
method='pearson', alternative=alt)
npt.assert_equal(obs, (1.0, 1.0))
def test_one_sided_less(self):
# no need to seed here as permuted test statistics will all be less
# than or equal to the observed test statistic (1.0)
for method in self.methods:
obs = mantel(self.minx,
self.minx,
method=method,
alternative='less')
self.assertEqual(obs, (1, 1))
np.random.seed(0)
obs = mantel(self.minx, self.miny, alternative='less')
self.assertAlmostEqual(obs[0], self.exp_x_vs_y)
self.assertAlmostEqual(obs[1], 0.843)
obs = mantel(self.minx, self.minz, alternative='less')
self.assertAlmostEqual(obs[0], self.exp_x_vs_z)
self.assertAlmostEqual(obs[1], 0.172)
def test_statistic_same_across_alternatives_and_permutations(self):
# Varying permutations and alternative hypotheses shouldn't affect the
# computed test statistics.
for n in (0, 99, 999):
for alt in self.alternatives:
for method, exp in (('pearson', self.exp_x_vs_y),
('spearman', 0.5)):
obs = mantel(self.minx, self.miny, method=method,
permutations=n, alternative=alt)[0]
self.assertAlmostEqual(obs, exp)
def test_no_variation_spearman(self):
exp = (np.nan, np.nan)
for alt in self.alternatives:
obs = mantel(self.miny,
self.no_variation,
method='spearman',
alternative=alt)
npt.assert_equal(obs, exp)
obs = mantel(self.no_variation,
self.miny,
method='spearman',
alternative=alt)
npt.assert_equal(obs, exp)
obs = mantel(self.no_variation,
self.no_variation,
method='spearman',
alternative=alt)
npt.assert_equal(obs, exp)
def test_invalid_input(self):
# invalid correlation method
with self.assertRaises(ValueError):
mantel([[1]], [[1]], method='brofist')
# invalid permutations
with self.assertRaises(ValueError):
mantel([[1]], [[1]], permutations=-1)
# invalid alternative
with self.assertRaises(ValueError):
mantel([[1]], [[1]], alternative='no cog yay')
# mismatched shape
with self.assertRaises(ValueError):
mantel(self.minx, [[0, 2], [2, 0]])
# too small dms
with self.assertRaises(ValueError):
mantel([[0, 3], [3, 0]], [[0, 2], [2, 0]])
def test_zero_permutations(self):
for alt in self.alternatives:
for method, exp in (('pearson', self.exp_x_vs_y), ('spearman',
0.5)):
obs = mantel(self.minx,
self.miny,
permutations=0,
method=method,
alternative=alt)
self.assertAlmostEqual(obs[0], exp)
npt.assert_equal(obs[1], np.nan)
# swapping order of matrices should give same result
obs = mantel(self.miny,
self.minx,
permutations=0,
method=method,
alternative=alt)
self.assertAlmostEqual(obs[0], exp)
npt.assert_equal(obs[1], np.nan)
def test_invalid_input(self):
# invalid correlation method
with self.assertRaises(ValueError):
mantel([[1]], [[1]], method='brofist')
# invalid permutations
with self.assertRaises(ValueError):
mantel([[1]], [[1]], permutations=-1)
# invalid alternative
with self.assertRaises(ValueError):
mantel([[1]], [[1]], alternative='no cog yay')
# mismatched shape
with self.assertRaises(ValueError):
mantel(self.minx, [[0, 2], [2, 0]])
# too small dms
with self.assertRaises(ValueError):
mantel([[0, 3], [3, 0]], [[0, 2], [2, 0]])
def test_distance_matrix_instances_as_input(self):
# IDs shouldn't matter -- the function should only care about the
# matrix data
dmx = DistanceMatrix(self.minx)
dmy = DistanceMatrix(self.miny, ['no', 'cog', 'yay'])
np.random.seed(0)
obs = mantel(dmx, dmy, alternative='less')
self.assertAlmostEqual(obs[0], self.exp_x_vs_y)
self.assertAlmostEqual(obs[1], 0.843)
def test_distance_matrix_instances_as_input(self):
# IDs shouldn't matter -- the function should only care about the
# matrix data
dmx = DistanceMatrix(self.minx)
dmy = DistanceMatrix(self.miny, ['no', 'cog', 'yay'])
np.random.seed(0)
obs = mantel(dmx, dmy, alternative='less')
self.assertAlmostEqual(obs[0], self.exp_x_vs_y)
self.assertAlmostEqual(obs[1], 0.843)
def test_statistic_same_across_alternatives_and_permutations(self):
# Varying permutations and alternative hypotheses shouldn't affect the
# computed test statistics.
for n in (0, 99, 999):
for alt in self.alternatives:
for method, exp in (('pearson', self.exp_x_vs_y), ('spearman',
0.5)):
obs = mantel(self.minx,
self.miny,
method=method,
permutations=n,
alternative=alt)[0]
self.assertAlmostEqual(obs, exp)
def test_two_sided(self):
np.random.seed(0)
obs = mantel(self.minx,
self.minx,
method='spearman',
alternative='two-sided')
self.assertEqual(obs[0], 1)
self.assertAlmostEqual(obs[1], 0.328)
obs = mantel(self.minx,
self.miny,
method='spearman',
alternative='two-sided')
self.assertAlmostEqual(obs[0], 0.5)
self.assertAlmostEqual(obs[1], 1.0)
obs = mantel(self.minx,
self.minz,
method='spearman',
alternative='two-sided')
self.assertAlmostEqual(obs[0], -1)
self.assertAlmostEqual(obs[1], 0.322)
def test_no_variation_pearson(self):
# Output doesn't match vegan::mantel with method='pearson'. Consider
# revising output and this test depending on outcome of
# https://github.com/scipy/scipy/issues/3728
for alt in self.alternatives:
# test one or both inputs having no variation in their
# distances
obs = mantel(self.miny,
self.no_variation,
method='pearson',
alternative=alt)
npt.assert_equal(obs, (0.0, 1.0))
obs = mantel(self.no_variation,
self.miny,
method='pearson',
alternative=alt)
npt.assert_equal(obs, (0.0, 1.0))
obs = mantel(self.no_variation,
self.no_variation,
method='pearson',
alternative=alt)
npt.assert_equal(obs, (1.0, 1.0))
def compute_mantel(result_tables,
taxonomy_level=6,
random_trials=999):
""" Compute mantel r and p-values for a set of results
result_tables: 2d list of tables to be compared,
where the data in the inner list is:
[dataset_id, reference_database_id, method_id,
parameter_combination_id, table_fp]
taxonomy_level: level to compute results
random_trials : number of Monte Carlo trials to run in Mantel test
"""
collapse_by_taxonomy = get_taxonomy_collapser(taxonomy_level)
results = []
for dataset_id, reference_id, method_id, params, actual_table_fp in result_tables:
## load the table and collapse it at the specified taxonomic level
try:
full_table = load_table(actual_table_fp)
except ValueError:
raise ValueError("Couldn't parse BIOM table: %s" % actual_table_fp)
collapsed_table = full_table.collapse(collapse_by_taxonomy,
axis='observation',
min_group_size=1)
## Compute Bray-Curtis distances between samples in the full table and
## in the collapsed table, and compare them with Mantel.
# This is way too compute-intensive because we're computing the actual
# dm everytime, which doesn't need to happen.
collapsed_dm = distance_matrix_from_table(collapsed_table)
full_dm = distance_matrix_from_table(full_table)
mantel_r, p = mantel(collapsed_dm, full_dm)
results.append((dataset_id, reference_id, method_id, params, mantel_r, p))
return pd.DataFrame(results, columns=["Dataset", "Reference", "Method",
"Parameters", "Mantel r", "Mantel p"])
def test_negative_correlation(self):
for method, exp in (('pearson', self.exp_x_vs_z), ('spearman', -1)):
obs = mantel(self.minx, self.minz, method=method)[0]
self.assertAlmostEqual(obs, exp)
def test_negative_correlation(self):
for method, exp in (('pearson', self.exp_x_vs_z), ('spearman', -1)):
obs = mantel(self.minx, self.minz, method=method)[0]
self.assertAlmostEqual(obs, exp)
