tests.test_clustering.MPSTestCases.test_mean_pairwise_similarity() - Code Metrics - Inspection of "added testing to cover clustering & exceptions for..." - chrislit/abydos - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 253783...d1b33f )

by Chris

created 2018-10-02 01:09 UTC

MPSTestCases.test_mean_pairwise_similarity() B

↳ Parent: tests.test_clustering

Complexity

Conditions

Size

Total Lines	54
Code Lines	50

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	1
eloc	50
nop	1
dl	0
loc	54
rs	8.6363
c	0
b	0
f	0

How to fix Long Method

# -*- coding: utf-8 -*-

# Copyright 2014-2018 by Christopher C. Little.
# This file is part of Abydos.
#
# Abydos is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Abydos is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with Abydos. If not, see <http://www.gnu.org/licenses/>.

"""abydos.tests.test_clustering.

This module contains unit tests for abydos.clustering
"""

from __future__ import unicode_literals

import unittest

import abydos.stats as stats
from abydos.distance import sim_tanimoto
from abydos.clustering import mean_pairwise_similarity, \
    pairwise_similarity_statistics


NIALL = ('Niall', 'Neal', 'Neil', 'Njall', 'Njáll', 'Nigel', 'Neel', 'Nele',
         'Nigelli', 'Nel', 'Kneale', 'Uí Néill', 'O\'Neill', 'MacNeil',
         'MacNele', 'Niall Noígíallach')

NIALL_1WORD = ('Niall', 'Neal', 'Neil', 'Njall', 'Njáll', 'Nigel', 'Neel',
               'Nele', 'Nigelli', 'Nel', 'Kneale', 'O\'Neill', 'MacNeil',
               'MacNele')


class MPSTestCases(unittest.TestCase):
    """Test mean pairwise similarity functions.

    abydos.clustering.mean_pairwise_similarity
    """

    def test_mean_pairwise_similarity(self):
        """Test abydos.clustering.mean_pairwise_similarity."""
        self.assertEqual(mean_pairwise_similarity(NIALL), 0.29362587170180671)
        self.assertEqual(mean_pairwise_similarity(NIALL, symmetric=True),
                         0.2936258717018066)
        self.assertEqual(mean_pairwise_similarity(NIALL,
                                                  mean_func=stats.hmean),
                         0.29362587170180671)
        self.assertEqual(mean_pairwise_similarity(NIALL, mean_func=stats.hmean,
                                                  symmetric=True),
                         0.2936258717018066)
        self.assertEqual(mean_pairwise_similarity(NIALL,
                                                  mean_func=stats.gmean),
                         0.33747245800668441)
        self.assertEqual(mean_pairwise_similarity(NIALL, mean_func=stats.gmean,
                                                  symmetric=True),
                         0.33747245800668441)
        self.assertEqual(mean_pairwise_similarity(NIALL,
                                                  mean_func=stats.amean),
                         0.38009278711484601)
        self.assertEqual(mean_pairwise_similarity(NIALL, mean_func=stats.amean,
                                                  symmetric=True),
                         0.38009278711484623)

        self.assertEqual(mean_pairwise_similarity(NIALL_1WORD),
                         mean_pairwise_similarity(' '.join(NIALL_1WORD)))
        self.assertEqual(mean_pairwise_similarity(NIALL_1WORD, symmetric=True),
                         mean_pairwise_similarity(' '.join(NIALL_1WORD),
                                                  symmetric=True))
        self.assertEqual(mean_pairwise_similarity(NIALL_1WORD,
                                                  mean_func=stats.gmean),
                         mean_pairwise_similarity(' '.join(NIALL_1WORD),
                                                  mean_func=stats.gmean))
        self.assertEqual(mean_pairwise_similarity(NIALL_1WORD,
                                                  mean_func=stats.amean),
                         mean_pairwise_similarity(' '.join(NIALL_1WORD),
                                                  mean_func=stats.amean))

        self.assertRaises(ValueError, mean_pairwise_similarity, ['a b c'])
        self.assertRaises(ValueError, mean_pairwise_similarity, 'abc')
        self.assertRaises(ValueError, mean_pairwise_similarity, 0)
        self.assertRaises(ValueError, mean_pairwise_similarity, NIALL,
                          mean_func='imaginary')
        self.assertRaises(ValueError, mean_pairwise_similarity, NIALL,
                          metric='imaginary')

        self.assertEqual(mean_pairwise_similarity(NIALL),
                         mean_pairwise_similarity(tuple(NIALL)))
        self.assertEqual(mean_pairwise_similarity(NIALL),
                         mean_pairwise_similarity(list(NIALL)))
        self.assertAlmostEqual(mean_pairwise_similarity(NIALL),
                               mean_pairwise_similarity(sorted(NIALL)))
        self.assertAlmostEqual(mean_pairwise_similarity(NIALL),
                               mean_pairwise_similarity(set(NIALL)))

class PSSTestCases(unittest.TestCase):
    """Test pairwise similarity statistics functions.

    abydos.clustering.pairwise_similarity_statistics
    """

    def test_pairwise_similarity_statistics(self):
        """Test abydos.clustering.pairwise_similarity_statistics."""
        (pw_max, pw_min, pw_mean,
         pw_std) = pairwise_similarity_statistics(NIALL, NIALL)
        self.assertAlmostEqual(pw_max, 1.0)
        self.assertAlmostEqual(pw_min, 0.11764705882352944)
        self.assertAlmostEqual(pw_mean, 0.4188369879201684)
        self.assertAlmostEqual(pw_std, 0.2265099631340623)

        (pw_max, pw_min, pw_mean,
         pw_std) = pairwise_similarity_statistics(NIALL, ('Kneal',))
        self.assertAlmostEqual(pw_max, 0.8333333333333334)
        self.assertAlmostEqual(pw_min, 0.11764705882352944)
        self.assertAlmostEqual(pw_mean, 0.30474877450980387)
        self.assertAlmostEqual(pw_std, 0.1842666797571549)

        # Test symmetric
        (pw_max, pw_min, pw_mean,
         pw_std) = pairwise_similarity_statistics(NIALL, NIALL, symmetric=True)
        self.assertAlmostEqual(pw_max, 1.0)
        self.assertAlmostEqual(pw_min, 0.11764705882352944)
        self.assertAlmostEqual(pw_mean, 0.4188369879201679)
        self.assertAlmostEqual(pw_std, 0.22650996313406255)

        (pw_max, pw_min, pw_mean,
         pw_std) = pairwise_similarity_statistics(NIALL, ('Kneal',),
                                                  symmetric=True)
        self.assertAlmostEqual(pw_max, 0.8333333333333334)
        self.assertAlmostEqual(pw_min, 0.11764705882352944)
        self.assertAlmostEqual(pw_mean, 0.304748774509804)
        self.assertAlmostEqual(pw_std, 0.18426667975715486)

        # Test with splittable strings
        (pw_max, pw_min, pw_mean,
         pw_std) = pairwise_similarity_statistics('The quick brown fox',
                                                  'jumped over the lazy dog.')
        self.assertAlmostEqual(pw_max, 0.6666666666666667)
        self.assertAlmostEqual(pw_min, 0.0)
        self.assertAlmostEqual(pw_mean, 0.08499999999999999)
        self.assertAlmostEqual(pw_std, 0.16132265804901677)

        (pw_max, pw_min, pw_mean,
         pw_std) = pairwise_similarity_statistics('The', 'jumped')
        self.assertAlmostEqual(pw_max, 0.16666666666666663)
        self.assertAlmostEqual(pw_min, 0.16666666666666663)
        self.assertAlmostEqual(pw_mean, 0.16666666666666663)
        self.assertAlmostEqual(pw_std, 0.0)

        # Test with a set metric
        (pw_max, pw_min, pw_mean,
         pw_std) = pairwise_similarity_statistics(NIALL, NIALL,
                                                  metric=sim_tanimoto)
        self.assertAlmostEqual(pw_max, 1.0)
        self.assertAlmostEqual(pw_min, 0.0)
        self.assertAlmostEqual(pw_mean, 0.23226906681010506)
        self.assertAlmostEqual(pw_std, 0.24747101181262784)

        # Test using hmean'
        (pw_max, pw_min, pw_mean,
         pw_std) = pairwise_similarity_statistics(NIALL, NIALL,
                                                  mean_func=stats.hmean)
        self.assertAlmostEqual(pw_max, 1.0)
        self.assertAlmostEqual(pw_min, 0.11764705882352944)
        self.assertAlmostEqual(pw_mean, 0.30718771249150056)
        self.assertAlmostEqual(pw_std, 0.25253182790044676)

        # Test exceptions
        self.assertRaises(ValueError, pairwise_similarity_statistics, NIALL,
                          NIALL, mean_func=None)
        self.assertRaises(ValueError, pairwise_similarity_statistics, NIALL,
                          NIALL, metric=None)
        self.assertRaises(ValueError, pairwise_similarity_statistics, 5, NIALL)
        self.assertRaises(ValueError, pairwise_similarity_statistics, NIALL, 5)

if __name__ == '__main__':
    unittest.main()


1			# -- coding: utf-8 --
2
3			# Copyright 2014-2018 by Christopher C. Little.
4			# This file is part of Abydos.
5			#
6			# Abydos is free software: you can redistribute it and/or modify
7			# it under the terms of the GNU General Public License as published by
8			# the Free Software Foundation, either version 3 of the License, or
9			# (at your option) any later version.
10			#
11			# Abydos is distributed in the hope that it will be useful,
12			# but WITHOUT ANY WARRANTY; without even the implied warranty of
13			# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			# GNU General Public License for more details.
15			#
16			# You should have received a copy of the GNU General Public License
17			# along with Abydos. If not, see <http://www.gnu.org/licenses/>.
18
19			"""abydos.tests.test_clustering.
20
21			This module contains unit tests for abydos.clustering
22			"""
23
24			from __future__ import unicode_literals
25
26			import unittest
27
28			import abydos.stats as stats
29			from abydos.distance import sim_tanimoto
30			from abydos.clustering import mean_pairwise_similarity, \
31			pairwise_similarity_statistics
32
33
34			NIALL = ('Niall', 'Neal', 'Neil', 'Njall', 'Njáll', 'Nigel', 'Neel', 'Nele',
35			'Nigelli', 'Nel', 'Kneale', 'Uí Néill', 'O\'Neill', 'MacNeil',
36			'MacNele', 'Niall Noígíallach')
37
38			NIALL_1WORD = ('Niall', 'Neal', 'Neil', 'Njall', 'Njáll', 'Nigel', 'Neel',
39			'Nele', 'Nigelli', 'Nel', 'Kneale', 'O\'Neill', 'MacNeil',
40			'MacNele')
41
42
43			class MPSTestCases(unittest.TestCase):
44			"""Test mean pairwise similarity functions.
45
46			abydos.clustering.mean_pairwise_similarity
47			"""
48
49			def test_mean_pairwise_similarity(self):
50			"""Test abydos.clustering.mean_pairwise_similarity."""
51			self.assertEqual(mean_pairwise_similarity(NIALL), 0.29362587170180671)
52			self.assertEqual(mean_pairwise_similarity(NIALL, symmetric=True),
53			0.2936258717018066)
54			self.assertEqual(mean_pairwise_similarity(NIALL,
55			mean_func=stats.hmean),
56			0.29362587170180671)
57			self.assertEqual(mean_pairwise_similarity(NIALL, mean_func=stats.hmean,
58			symmetric=True),
59			0.2936258717018066)
60			self.assertEqual(mean_pairwise_similarity(NIALL,
61			mean_func=stats.gmean),
62			0.33747245800668441)
63			self.assertEqual(mean_pairwise_similarity(NIALL, mean_func=stats.gmean,
64			symmetric=True),
65			0.33747245800668441)
66			self.assertEqual(mean_pairwise_similarity(NIALL,
67			mean_func=stats.amean),
68			0.38009278711484601)
69			self.assertEqual(mean_pairwise_similarity(NIALL, mean_func=stats.amean,
70			symmetric=True),
71			0.38009278711484623)
72
73			self.assertEqual(mean_pairwise_similarity(NIALL_1WORD),
74			mean_pairwise_similarity(' '.join(NIALL_1WORD)))
75			self.assertEqual(mean_pairwise_similarity(NIALL_1WORD, symmetric=True),
76			mean_pairwise_similarity(' '.join(NIALL_1WORD),
77			symmetric=True))
78			self.assertEqual(mean_pairwise_similarity(NIALL_1WORD,
79			mean_func=stats.gmean),
80			mean_pairwise_similarity(' '.join(NIALL_1WORD),
81			mean_func=stats.gmean))
82			self.assertEqual(mean_pairwise_similarity(NIALL_1WORD,
83			mean_func=stats.amean),
84			mean_pairwise_similarity(' '.join(NIALL_1WORD),
85			mean_func=stats.amean))
86
87			self.assertRaises(ValueError, mean_pairwise_similarity, ['a b c'])
88			self.assertRaises(ValueError, mean_pairwise_similarity, 'abc')
89			self.assertRaises(ValueError, mean_pairwise_similarity, 0)
90			self.assertRaises(ValueError, mean_pairwise_similarity, NIALL,
91			mean_func='imaginary')
92			self.assertRaises(ValueError, mean_pairwise_similarity, NIALL,
93			metric='imaginary')
94
95			self.assertEqual(mean_pairwise_similarity(NIALL),
96			mean_pairwise_similarity(tuple(NIALL)))
97			self.assertEqual(mean_pairwise_similarity(NIALL),
98			mean_pairwise_similarity(list(NIALL)))
99			self.assertAlmostEqual(mean_pairwise_similarity(NIALL),
100			mean_pairwise_similarity(sorted(NIALL)))
101			self.assertAlmostEqual(mean_pairwise_similarity(NIALL),
102			mean_pairwise_similarity(set(NIALL)))
103
104			class PSSTestCases(unittest.TestCase):
105			"""Test pairwise similarity statistics functions.
106
107			abydos.clustering.pairwise_similarity_statistics
108			"""
109
110			def test_pairwise_similarity_statistics(self):
111			"""Test abydos.clustering.pairwise_similarity_statistics."""
112			(pw_max, pw_min, pw_mean,
113			pw_std) = pairwise_similarity_statistics(NIALL, NIALL)
114			self.assertAlmostEqual(pw_max, 1.0)
115			self.assertAlmostEqual(pw_min, 0.11764705882352944)
116			self.assertAlmostEqual(pw_mean, 0.4188369879201684)
117			self.assertAlmostEqual(pw_std, 0.2265099631340623)
118
119			(pw_max, pw_min, pw_mean,
120			pw_std) = pairwise_similarity_statistics(NIALL, ('Kneal',))
121			self.assertAlmostEqual(pw_max, 0.8333333333333334)
122			self.assertAlmostEqual(pw_min, 0.11764705882352944)
123			self.assertAlmostEqual(pw_mean, 0.30474877450980387)
124			self.assertAlmostEqual(pw_std, 0.1842666797571549)
125
126			# Test symmetric
127			(pw_max, pw_min, pw_mean,
128			pw_std) = pairwise_similarity_statistics(NIALL, NIALL, symmetric=True)
129			self.assertAlmostEqual(pw_max, 1.0)
130			self.assertAlmostEqual(pw_min, 0.11764705882352944)
131			self.assertAlmostEqual(pw_mean, 0.4188369879201679)
132			self.assertAlmostEqual(pw_std, 0.22650996313406255)
133
134			(pw_max, pw_min, pw_mean,
135			pw_std) = pairwise_similarity_statistics(NIALL, ('Kneal',),
136			symmetric=True)
137			self.assertAlmostEqual(pw_max, 0.8333333333333334)
138			self.assertAlmostEqual(pw_min, 0.11764705882352944)
139			self.assertAlmostEqual(pw_mean, 0.304748774509804)
140			self.assertAlmostEqual(pw_std, 0.18426667975715486)
141
142			# Test with splittable strings
143			(pw_max, pw_min, pw_mean,
144			pw_std) = pairwise_similarity_statistics('The quick brown fox',
145			'jumped over the lazy dog.')
146			self.assertAlmostEqual(pw_max, 0.6666666666666667)
147			self.assertAlmostEqual(pw_min, 0.0)
148			self.assertAlmostEqual(pw_mean, 0.08499999999999999)
149			self.assertAlmostEqual(pw_std, 0.16132265804901677)
150
151			(pw_max, pw_min, pw_mean,
152			pw_std) = pairwise_similarity_statistics('The', 'jumped')
153			self.assertAlmostEqual(pw_max, 0.16666666666666663)
154			self.assertAlmostEqual(pw_min, 0.16666666666666663)
155			self.assertAlmostEqual(pw_mean, 0.16666666666666663)
156			self.assertAlmostEqual(pw_std, 0.0)
157
158			# Test with a set metric
159			(pw_max, pw_min, pw_mean,
160			pw_std) = pairwise_similarity_statistics(NIALL, NIALL,
161			metric=sim_tanimoto)
162			self.assertAlmostEqual(pw_max, 1.0)
163			self.assertAlmostEqual(pw_min, 0.0)
164			self.assertAlmostEqual(pw_mean, 0.23226906681010506)
165			self.assertAlmostEqual(pw_std, 0.24747101181262784)
166
167			# Test using hmean'
168			(pw_max, pw_min, pw_mean,
169			pw_std) = pairwise_similarity_statistics(NIALL, NIALL,
170			mean_func=stats.hmean)
171			self.assertAlmostEqual(pw_max, 1.0)
172			self.assertAlmostEqual(pw_min, 0.11764705882352944)
173			self.assertAlmostEqual(pw_mean, 0.30718771249150056)
174			self.assertAlmostEqual(pw_std, 0.25253182790044676)
175
176			# Test exceptions
177			self.assertRaises(ValueError, pairwise_similarity_statistics, NIALL,
178			NIALL, mean_func=None)
179			self.assertRaises(ValueError, pairwise_similarity_statistics, NIALL,
180			NIALL, metric=None)
181			self.assertRaises(ValueError, pairwise_similarity_statistics, 5, NIALL)
182			self.assertRaises(ValueError, pairwise_similarity_statistics, NIALL, 5)
183
184			if __name__ == '__main__':
185			unittest.main()
186

chrislit / abydos

Push — master ( 253783...d1b33f )

MPSTestCases.test_mean_pairwise_similarity() B

Complexity

Size

Duplication

Importance

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like