1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
|
# ----------------------------------------------------------------------------
# Copyright (c) 2013--, scikit-bio development team.
#
# Distributed under the terms of the Modified BSD License.
#
# The full license is in the file LICENSE.txt, distributed with this software.
# ----------------------------------------------------------------------------
from unittest import TestCase, main
import copy
import numpy as np
import numpy.testing as npt
from skbio.stats.ordination import corr, mean_and_std, e_matrix, f_matrix, \
center_distance_matrix
from skbio.stats.ordination._utils import _e_matrix_inplace, _f_matrix_inplace
class TestUtils(TestCase):
def setUp(self):
self.x = np.array([[1, 2, 3], [4, 5, 6]])
self.y = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
self.matrix = np.arange(1, 7).reshape(2, 3)
self.matrix2 = np.arange(1, 10).reshape(3, 3)
self.small_mat = np.array([[7, 5, 5], [4, 4, 9], [7, 5, 3]])
self.dist_mat = np.asarray([[0., 7., 5., 5.], [7., 0., 4., 9.],
[5., 4., 0., 3.], [5., 9., 3., 0.]],
dtype=np.float64)
self.dist_mat_fp32 = np.asarray([[0., 7., 5., 5.], [7., 0., 4., 9.],
[5., 4., 0., 3.], [5., 9., 3., 0.]],
dtype=np.float32)
def test_mean_and_std(self):
obs = mean_and_std(self.x)
npt.assert_almost_equal((3.5, 1.707825127), obs)
obs = mean_and_std(self.x, with_std=False)
self.assertEqual((3.5, None), obs)
obs = mean_and_std(self.x, ddof=2)
npt.assert_almost_equal((3.5, 2.091650066), obs)
def test_mean_and_std_no_mean_no_std(self):
with npt.assert_raises(ValueError):
mean_and_std(self.x, with_mean=False, with_std=False)
def test_corr(self):
obs = corr(self.small_mat)
npt.assert_almost_equal(np.array([[1, 1, -0.94491118],
[1, 1, -0.94491118],
[-0.94491118, -0.94491118, 1]]),
obs)
def test_corr_shape_mismatch(self):
with npt.assert_raises(ValueError):
corr(self.x, self.y)
def test_e_matrix(self):
E = e_matrix(self.matrix)
expected_E = np.array([[-0.5, -2., -4.5],
[-8., -12.5, -18.]])
npt.assert_almost_equal(E, expected_E)
def test_f_matrix(self):
F = f_matrix(self.matrix2)
expected_F = np.zeros((3, 3))
# Note that `test_make_F_matrix` in cogent is wrong
npt.assert_almost_equal(F, expected_F)
def test_e_matrix_inplace(self):
E = _e_matrix_inplace(self.matrix)
expected_E = np.array([[-0.5, -2., -4.5],
[-8., -12.5, -18.]])
npt.assert_almost_equal(E, expected_E)
def test_f_matrix_inplace(self):
F = _f_matrix_inplace(self.matrix2)
expected_F = np.zeros((3, 3))
npt.assert_almost_equal(F, expected_F)
def test_center_distance_matrix_inplace(self):
dm_expected = f_matrix(e_matrix(self.dist_mat))
# make copy of matrix to test inplace centering
matrix_copy = copy.deepcopy(self.dist_mat)
dm_centered = center_distance_matrix(matrix_copy, inplace=False)
# ensure that matrix_copy was NOT modified inplace
self.assertTrue(np.array_equal(matrix_copy, self.dist_mat))
# and ensure that the result of centering was correct
npt.assert_almost_equal(dm_expected, dm_centered)
# next, sort same matrix inplace
matrix_copy2 = copy.deepcopy(self.dist_mat)
dm_centered_inp = center_distance_matrix(matrix_copy2, inplace=True)
# and ensure that the result of inplace centering was correct
npt.assert_almost_equal(dm_expected, dm_centered_inp)
def test_center_distance_matrix_single(self):
dm_expected = f_matrix(e_matrix(self.dist_mat_fp32))
# make copy of matrix to test inplace centering
matrix_copy = copy.deepcopy(self.dist_mat_fp32)
dm_centered = center_distance_matrix(matrix_copy, inplace=False)
# ensure that matrix_copy was NOT modified inplace
self.assertTrue(np.array_equal(matrix_copy, self.dist_mat_fp32))
# and ensure that the result of centering was correct
npt.assert_almost_equal(dm_expected, dm_centered)
# next, sort same matrix inplace
matrix_copy2 = copy.deepcopy(self.dist_mat_fp32)
dm_centered_inp = center_distance_matrix(matrix_copy2, inplace=True)
# and ensure that the result of inplace centering was correct
npt.assert_almost_equal(dm_expected, dm_centered_inp)
if __name__ == '__main__':
main()
|
