thuban/test/test_classgen.py

# Copyright (c) 2002, 2003 by Intevation GmbH
# Authors:
# Bernhard Herzog <[email protected]>
#
# This program is free software under the GPL (>=v2)
# Read the file COPYING coming with Thuban for details.

"""
Test the Menu
"""

__version__ = "$Revision$"

import unittest

import support
support.initthuban()

from Thuban.Model.classgen import \
    generate_singletons, \
    generate_uniform_distribution, \
    generate_quantiles, \
    calculate_quantiles, \
    GreyRamp
from Thuban.Model.range import Range

from Thuban.Model.classification import ClassGroupRange

class ClassGenTest(unittest.TestCase):

    def doClassRangeTest(self, clazz, ranges):
        self.assertEquals(clazz.GetNumGroups(), len(ranges))
        for i in range(len(ranges)):
            group = clazz.GetGroup(i)
            r1 = str(Range(ranges[i]))
            r2 = group.GetRange()
            self.assertEquals(r1, r2)

    def doClassSingleTest(self, clazz, _list):
        self.assertEquals(clazz.GetNumGroups(), len(_list))
        for i in range(len(_list)):
            group = clazz.GetGroup(i)
            self.assertEquals(group.GetValue(), _list[i])
            
    def test_generate_singletons(self):
        """Test generate_singletons"""

        eq = self.assertEquals
        gs = generate_singletons
        ramp = GreyRamp

        _list = [1, 2, 3, 4]
        cl = gs(_list, ramp)
        self.doClassSingleTest(cl, _list)

        _list = range(0, 100)
        cl = gs(_list, ramp)
        self.doClassSingleTest(cl, _list)

        _list = range(-100, 100)
        cl = gs(_list, ramp)
        self.doClassSingleTest(cl, _list)

        _list = ['a', 'b', 'c', 'd']
        cl = gs(_list, ramp)
        self.doClassSingleTest(cl, _list)

        _list = []
        cl = gs(_list, ramp)
        self.doClassSingleTest(cl, _list)

        _list = [1]
        cl = gs(_list, ramp)
        self.doClassSingleTest(cl, _list)
        

    def test_generate_uniform_distribution(self):
        """Test generate_uniform_distribution"""

        eq = self.assertEquals
        gud = generate_uniform_distribution
        ramp = GreyRamp

        cl = gud(0, 99, 10, ramp, True)
        self.doClassRangeTest(cl, ("[0;10[", "[10;20[", "[20;30[", "[30;40[",
                              "[40;50[", "[50;60[", "[60;70[", "[70;80[",
                              "[80;90[", "[90;99]"))

        cl = gud(0, 99, 10, ramp, False)
        self.doClassRangeTest(cl, ("[0;9.9[", "[9.9;19.8[", "[19.8;29.7[", 
                              "[29.7;39.6[", "[39.6;49.5[", "[49.5;59.4[", 
                              "[59.4;69.3[", "[69.3;79.2[", "[79.2;89.1[", 
                              "[89.1;99.0]"))

        cl = gud(1, 2, 2, ramp, False)
        self.doClassRangeTest(cl, ("[1;1.5[", "[1.5;2]"))

        cl = gud(1, 2, 2, ramp, True)
        self.doClassRangeTest(cl, ("[1;2[", "[2;2]"))


    def test_generate_quantiles(self):
        """Test generate_quantiles"""

        eq = self.assertEquals

        #
        # Test calculate_quantiles
        #

        gq = generate_quantiles

        ramp = GreyRamp

        adj, cl = gq([1, 2, 3, 4], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
        self.failIf(adj)
        self.doClassRangeTest(cl, ("[1;1]", "]1;2]", "]2;3]", "]3;4]"))

        adj, cl = gq(range(0, 100), [.25, .5, .75, 1.0], ramp, Range("[0;100["))
        self.failIf(adj)
        self.doClassRangeTest(cl, ("[0;24]", "]24;49]", "]49;74]", "]74;100["))

        adj, cl = gq(range(0, 100), [.33, .66, 1.0], ramp, Range("[0;100]"))
        self.failIf(adj)
        self.doClassRangeTest(cl, ("[0;32]", "]32;65]", "]65;100]"))

        # negative input
        adj,cl = gq(range(-100,100), [.33, .66, 1.0], ramp, Range("[-100;100]"))
        self.failIf(adj)
        self.doClassRangeTest(cl, ("[-100;-35]", "]-35;31]", "]31;100]"))

        # unequal percentiles
        adj,cl = gq(range(0, 100), [.25, .66, .8, 1.0], ramp, Range("[0;100]"))
        self.failIf(adj)
        self.doClassRangeTest(cl, ("[0;24]", "]24;65]", "]65;79]", "]79;100]"))

        # input all the same
        adj,cl = gq([1, 1, 1, 1], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
        self.failUnless(adj)
        self.doClassRangeTest(cl, ("[1;4]",))

        # empty input
        adj,cl = gq([], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
        self.failUnless(adj)
        self.doClassRangeTest(cl, ())

        # empty range
        adj,cl = gq([1, 2, 3, 4], [.25, .5, .75, 1.0], ramp, Range("]0;1["))
        self.failUnless(adj)
        self.doClassRangeTest(cl, ())

        # empty percentiles
        self.assertRaises(ValueError, gq,
                          [1, 2, 3, 4], [], ramp, Range("]0;1["))

        # single percentile
        self.assertRaises(ValueError, gq,
                          [1, 2, 3, 4], [.5], ramp, Range("[0;4]"))

        # more percentiles than input
        adj,cl = gq([1], [.5, 1.0], ramp, Range("[0;4]"))
        self.failUnless(adj)
        self.doClassRangeTest(cl, ("[0;4]",))

        adj,cl = gq([1], [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1.0], ramp, Range("[0;4]"))
        self.failUnless(adj)
        self.doClassRangeTest(cl, ("[0;4]",))

        # range smaller than the input
        adj,cl = gq([1, 2, 3, 4], [.5, 1.0], ramp, Range("[2;3]"))
        self.failIf(adj)
        self.doClassRangeTest(cl, ("[2;2]","]2;3]"))

        # range outside the input
        adj,cl = gq([5, 6, 7, 8], [.5, 1.0], ramp, Range("[2;3]"))
        self.failUnless(adj)
        self.doClassRangeTest(cl, ())

        adj,cl = gq([1, 1, 1, 1, 1, 1], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
        self.failUnless(adj)
        self.doClassRangeTest(cl, ("[1;4]",))

        adj,cl = gq([1, 1, 1, 1, 1, 2, 3], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
        self.failUnless(adj)
        self.doClassRangeTest(cl, ("[1;1]", "]1;2]", "]2;4]"))

        # adjusted quantiles
        adj,cl = gq([1, 1, 1, 1, 1, 
                     2, 2, 2, 2, 2, 
                     3, 3, 3, 3, 3, 
                     4, 4, 4, 4, 4,
                     5, 5, 5, 5, 5], 
                    [.12, .24, .36, .50, .62, .76, .88, 1.0], ramp, Range("[1;5]"))
        
        self.failUnless(adj)
        self.doClassRangeTest(cl, ("[1;1]", "]1;2]", "]2;3]", "]3;4]", "]4;5]"))
        
    def test_calculate_quantiles(self):
        """Test calculate_quantiles"""

        eq = self.assertEquals

        #
        # Test calculate_quantiles
        #

        cq = calculate_quantiles

        result = cq([1, 2, 3, 4], [.25, .5, .75, 1.0], Range("[1;4]"))
        eq(result, (0, 0, 3, [(0, .25), (1, .5), (2, .75), (3, 1.0)]))

        result = cq(range(0, 100), [.25, .5, .75, 1.0], Range("[0;100]"))
        eq(result, (0, 0, 99, [(24, .25), (49, .5), (74, .75), (99, 1.0)]))

        result = cq(range(0, 100), [.33, .66, 1.0], Range("[0;100]"))
        eq(result, (0, 0, 99, [(32, .33), (65, .66), (99, 1.0)]))

        # negative input
        result = cq(range(-100, 100), [.33, .66, 1.0], Range("[-100;100]"))
        eq(result, (0, 0, 199, [(65, .33), (131, .66), (199, 1.0)]))

        # unequal percentiles
        result = cq(range(0, 100), [.25, .66, .8, 1.0], Range("[0;100]"))
        eq(result, (0, 0, 99, [(24, .25), (65, .66), (79, .8), (99, 1.0)]))

        # input all the same
        result = cq([1, 1, 1, 1], [.25, .5, .75, 1.0], Range("[1;4]"))
        eq(result, (1, 0, 3, [(3, 1.0)]))

        # empty input
        result = cq([], [.25, .5, .75, 1.0], Range("[1;4]"))
        eq(result, None)

        # empty range
        result = cq([1, 2, 3, 4], [.25, .5, .75, 1.0], Range("]0;1["))
        eq(result, None)

        # empty percentiles
        self.assertRaises(ValueError, cq, [1, 2, 3, 4], [], Range("]0;1["))

        # single percentile
        self.assertRaises(ValueError, cq, [1, 2, 3, 4], [.5], Range("[0;4]"))

        # percentile doesn't cover range
        self.assertRaises(ValueError, cq, [1, 2, 3, 4], [.5,.8], Range("[0;4]"))

        # more percentiles than input
        result = cq([1], [.5, 1.0], Range("[0;4]"))
        eq(result, (1, 0, 0, [(0, 1.0)]))

        result = cq([1], [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1.0], Range("[0;4]"))
        eq(result, (1, 0, 0, [(0, 1.0)]))

        # range smaller than the input
        result = cq([1, 2, 3, 4], [.5, 1.0], Range("[2;3]"))
        eq(result, (0, 1, 2, [(1, .5), (2, 1.0)]))

        # range outside the input
        result = cq([5, 6, 7, 8], [.5, 1.0], Range("[2;3]"))
        eq(result, None)

        result = cq([1, 1, 1, 1, 1, 1], [.25, .5, .75, 1.0], Range("[1;4]"))
        eq(result, (1, 0, 5, [(5, 1.0)]))

        result = cq([1, 1, 1, 1, 1, 2, 3], [.25, .5, .75, 1.0], Range("[1;4]"))
        eq(result, (1, 0, 6, 
               [(4, 0.7142857142857143), # the algorithm generated
                (5, 0.8571428571428571), # these values, but they are
                (6, 1.0)]))              # right.

        # adjusted quantiles
        result = cq([1, 1, 1, 1, 1, 
                     2, 2, 2, 2, 2, 
                     3, 3, 3, 3, 3, 
                     4, 4, 4, 4, 4,
                     5, 5, 5, 5, 5], 
                    [.12, .24, .36, .50, .62, .76, .88, 1.0], Range("[1;5]"))
        eq(result, (1, 0, 24, [(4, .2), (9, .4), (14, .6), (19, .8), (24, 1.0)]))

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

1	bh	1110	# Copyright (c) 2002, 2003 by Intevation GmbH
2	jonathan	890	# Authors:
3			# Bernhard Herzog <[email protected]>
4			#
5			# This program is free software under the GPL (>=v2)
6			# Read the file COPYING coming with Thuban for details.
7
8			"""
9			Test the Menu
10			"""
11
12			__version__ = "$Revision$"
13
14			import unittest
15
16			import support
17			support.initthuban()
18
19	jonathan	1166	from Thuban.Model.classgen import \
20			generate_singletons, \
21			generate_uniform_distribution, \
22			generate_quantiles, \
23			calculate_quantiles, \
24			GreyRamp
25	jonathan	890	from Thuban.Model.range import Range
26
27	jonathan	1166	from Thuban.Model.classification import ClassGroupRange
28
29	jonathan	890	class ClassGenTest(unittest.TestCase):
30
31	jonathan	1166	def doClassRangeTest(self, clazz, ranges):
32			self.assertEquals(clazz.GetNumGroups(), len(ranges))
33			for i in range(len(ranges)):
34			group = clazz.GetGroup(i)
35			r1 = str(Range(ranges[i]))
36			r2 = group.GetRange()
37			self.assertEquals(r1, r2)
38	jonathan	890
39	jonathan	1166	def doClassSingleTest(self, clazz, _list):
40			self.assertEquals(clazz.GetNumGroups(), len(_list))
41			for i in range(len(_list)):
42			group = clazz.GetGroup(i)
43			self.assertEquals(group.GetValue(), _list[i])
44
45			def test_generate_singletons(self):
46			"""Test generate_singletons"""
47
48	jonathan	890	eq = self.assertEquals
49	jonathan	1166	gs = generate_singletons
50	jonathan	1345	ramp = GreyRamp
51	jonathan	890
52	jonathan	1166	_list = [1, 2, 3, 4]
53	jonathan	1345	cl = gs(_list, ramp)
54	jonathan	1166	self.doClassSingleTest(cl, _list)
55
56			_list = range(0, 100)
57	jonathan	1345	cl = gs(_list, ramp)
58	jonathan	1166	self.doClassSingleTest(cl, _list)
59
60			_list = range(-100, 100)
61	jonathan	1345	cl = gs(_list, ramp)
62	jonathan	1166	self.doClassSingleTest(cl, _list)
63
64			_list = ['a', 'b', 'c', 'd']
65	jonathan	1345	cl = gs(_list, ramp)
66	jonathan	1166	self.doClassSingleTest(cl, _list)
67
68			_list = []
69	jonathan	1345	cl = gs(_list, ramp)
70	jonathan	1166	self.doClassSingleTest(cl, _list)
71
72			_list = [1]
73	jonathan	1345	cl = gs(_list, ramp)
74	jonathan	1166	self.doClassSingleTest(cl, _list)
75
76
77			def test_generate_uniform_distribution(self):
78			"""Test generate_uniform_distribution"""
79
80			eq = self.assertEquals
81			gud = generate_uniform_distribution
82	jonathan	1345	ramp = GreyRamp
83	jonathan	1166
84			cl = gud(0, 99, 10, ramp, True)
85			self.doClassRangeTest(cl, ("[0;10[", "[10;20[", "[20;30[", "[30;40[",
86			"[40;50[", "[50;60[", "[60;70[", "[70;80[",
87			"[80;90[", "[90;99]"))
88
89			cl = gud(0, 99, 10, ramp, False)
90			self.doClassRangeTest(cl, ("[0;9.9[", "[9.9;19.8[", "[19.8;29.7[",
91			"[29.7;39.6[", "[39.6;49.5[", "[49.5;59.4[",
92			"[59.4;69.3[", "[69.3;79.2[", "[79.2;89.1[",
93			"[89.1;99.0]"))
94
95			cl = gud(1, 2, 2, ramp, False)
96			self.doClassRangeTest(cl, ("[1;1.5[", "[1.5;2]"))
97
98			cl = gud(1, 2, 2, ramp, True)
99			self.doClassRangeTest(cl, ("[1;2[", "[2;2]"))
100
101
102			def test_generate_quantiles(self):
103			"""Test generate_quantiles"""
104
105			eq = self.assertEquals
106
107	jonathan	890	#
108	jonathan	1166	# Test calculate_quantiles
109	jonathan	890	#
110
111	jonathan	1166	gq = generate_quantiles
112	jonathan	890
113	jonathan	1345	ramp = GreyRamp
114	jonathan	1166
115			adj, cl = gq([1, 2, 3, 4], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
116			self.failIf(adj)
117			self.doClassRangeTest(cl, ("[1;1]", "]1;2]", "]2;3]", "]3;4]"))
118
119			adj, cl = gq(range(0, 100), [.25, .5, .75, 1.0], ramp, Range("[0;100["))
120			self.failIf(adj)
121			self.doClassRangeTest(cl, ("[0;24]", "]24;49]", "]49;74]", "]74;100["))
122
123			adj, cl = gq(range(0, 100), [.33, .66, 1.0], ramp, Range("[0;100]"))
124			self.failIf(adj)
125			self.doClassRangeTest(cl, ("[0;32]", "]32;65]", "]65;100]"))
126
127			# negative input
128			adj,cl = gq(range(-100,100), [.33, .66, 1.0], ramp, Range("[-100;100]"))
129			self.failIf(adj)
130			self.doClassRangeTest(cl, ("[-100;-35]", "]-35;31]", "]31;100]"))
131
132			# unequal percentiles
133			adj,cl = gq(range(0, 100), [.25, .66, .8, 1.0], ramp, Range("[0;100]"))
134			self.failIf(adj)
135			self.doClassRangeTest(cl, ("[0;24]", "]24;65]", "]65;79]", "]79;100]"))
136
137			# input all the same
138			adj,cl = gq([1, 1, 1, 1], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
139			self.failUnless(adj)
140			self.doClassRangeTest(cl, ("[1;4]",))
141
142			# empty input
143			adj,cl = gq([], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
144			self.failUnless(adj)
145			self.doClassRangeTest(cl, ())
146
147			# empty range
148			adj,cl = gq([1, 2, 3, 4], [.25, .5, .75, 1.0], ramp, Range("]0;1["))
149			self.failUnless(adj)
150			self.doClassRangeTest(cl, ())
151
152			# empty percentiles
153			self.assertRaises(ValueError, gq,
154			[1, 2, 3, 4], [], ramp, Range("]0;1["))
155
156			# single percentile
157			self.assertRaises(ValueError, gq,
158			[1, 2, 3, 4], [.5], ramp, Range("[0;4]"))
159
160			# more percentiles than input
161			adj,cl = gq([1], [.5, 1.0], ramp, Range("[0;4]"))
162			self.failUnless(adj)
163			self.doClassRangeTest(cl, ("[0;4]",))
164
165			adj,cl = gq([1], [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1.0], ramp, Range("[0;4]"))
166			self.failUnless(adj)
167			self.doClassRangeTest(cl, ("[0;4]",))
168
169			# range smaller than the input
170			adj,cl = gq([1, 2, 3, 4], [.5, 1.0], ramp, Range("[2;3]"))
171			self.failIf(adj)
172			self.doClassRangeTest(cl, ("[2;2]","]2;3]"))
173
174			# range outside the input
175			adj,cl = gq([5, 6, 7, 8], [.5, 1.0], ramp, Range("[2;3]"))
176			self.failUnless(adj)
177			self.doClassRangeTest(cl, ())
178
179			adj,cl = gq([1, 1, 1, 1, 1, 1], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
180			self.failUnless(adj)
181			self.doClassRangeTest(cl, ("[1;4]",))
182
183			adj,cl = gq([1, 1, 1, 1, 1, 2, 3], [.25, .5, .75, 1.0], ramp, Range("[1;4]"))
184			self.failUnless(adj)
185			self.doClassRangeTest(cl, ("[1;1]", "]1;2]", "]2;4]"))
186
187			# adjusted quantiles
188			adj,cl = gq([1, 1, 1, 1, 1,
189			2, 2, 2, 2, 2,
190			3, 3, 3, 3, 3,
191			4, 4, 4, 4, 4,
192			5, 5, 5, 5, 5],
193			[.12, .24, .36, .50, .62, .76, .88, 1.0], ramp, Range("[1;5]"))
194
195			self.failUnless(adj)
196			self.doClassRangeTest(cl, ("[1;1]", "]1;2]", "]2;3]", "]3;4]", "]4;5]"))
197
198			def test_calculate_quantiles(self):
199			"""Test calculate_quantiles"""
200
201			eq = self.assertEquals
202
203			#
204			# Test calculate_quantiles
205			#
206
207			cq = calculate_quantiles
208
209	jonathan	890	result = cq([1, 2, 3, 4], [.25, .5, .75, 1.0], Range("[1;4]"))
210	jonathan	896	eq(result, (0, 0, 3, [(0, .25), (1, .5), (2, .75), (3, 1.0)]))
211	jonathan	890
212			result = cq(range(0, 100), [.25, .5, .75, 1.0], Range("[0;100]"))
213	jonathan	896	eq(result, (0, 0, 99, [(24, .25), (49, .5), (74, .75), (99, 1.0)]))
214	jonathan	890
215			result = cq(range(0, 100), [.33, .66, 1.0], Range("[0;100]"))
216	jonathan	896	eq(result, (0, 0, 99, [(32, .33), (65, .66), (99, 1.0)]))
217	jonathan	890
218			# negative input
219			result = cq(range(-100, 100), [.33, .66, 1.0], Range("[-100;100]"))
220	jonathan	896	eq(result, (0, 0, 199, [(65, .33), (131, .66), (199, 1.0)]))
221	jonathan	890
222			# unequal percentiles
223			result = cq(range(0, 100), [.25, .66, .8, 1.0], Range("[0;100]"))
224	jonathan	896	eq(result, (0, 0, 99, [(24, .25), (65, .66), (79, .8), (99, 1.0)]))
225	jonathan	890
226			# input all the same
227			result = cq([1, 1, 1, 1], [.25, .5, .75, 1.0], Range("[1;4]"))
228	jonathan	896	eq(result, (1, 0, 3, [(3, 1.0)]))
229	jonathan	890
230			# empty input
231			result = cq([], [.25, .5, .75, 1.0], Range("[1;4]"))
232	jonathan	896	eq(result, None)
233	jonathan	890
234			# empty range
235			result = cq([1, 2, 3, 4], [.25, .5, .75, 1.0], Range("]0;1["))
236	jonathan	896	eq(result, None)
237	jonathan	890
238			# empty percentiles
239	jonathan	1166	self.assertRaises(ValueError, cq, [1, 2, 3, 4], [], Range("]0;1["))
240	jonathan	890
241			# single percentile
242	jonathan	1166	self.assertRaises(ValueError, cq, [1, 2, 3, 4], [.5], Range("[0;4]"))
243	jonathan	890
244	jonathan	1166	# percentile doesn't cover range
245			self.assertRaises(ValueError, cq, [1, 2, 3, 4], [.5,.8], Range("[0;4]"))
246
247	jonathan	890	# more percentiles than input
248			result = cq([1], [.5, 1.0], Range("[0;4]"))
249	jonathan	896	eq(result, (1, 0, 0, [(0, 1.0)]))
250	jonathan	890
251			result = cq([1], [.1, .2, .3, .4, .5, .6, .7, .8, .9, 1.0], Range("[0;4]"))
252	jonathan	896	eq(result, (1, 0, 0, [(0, 1.0)]))
253	jonathan	890
254			# range smaller than the input
255			result = cq([1, 2, 3, 4], [.5, 1.0], Range("[2;3]"))
256	jonathan	896	eq(result, (0, 1, 2, [(1, .5), (2, 1.0)]))
257	jonathan	890
258			# range outside the input
259			result = cq([5, 6, 7, 8], [.5, 1.0], Range("[2;3]"))
260	jonathan	896	eq(result, None)
261	jonathan	890
262			result = cq([1, 1, 1, 1, 1, 1], [.25, .5, .75, 1.0], Range("[1;4]"))
263	jonathan	896	eq(result, (1, 0, 5, [(5, 1.0)]))
264	jonathan	890
265			result = cq([1, 1, 1, 1, 1, 2, 3], [.25, .5, .75, 1.0], Range("[1;4]"))
266	jonathan	896	eq(result, (1, 0, 6,
267			[(4, 0.7142857142857143), # the algorithm generated
268			(5, 0.8571428571428571), # these values, but they are
269			(6, 1.0)])) # right.
270	jonathan	890
271			# adjusted quantiles
272			result = cq([1, 1, 1, 1, 1,
273			2, 2, 2, 2, 2,
274			3, 3, 3, 3, 3,
275			4, 4, 4, 4, 4,
276			5, 5, 5, 5, 5],
277			[.12, .24, .36, .50, .62, .76, .88, 1.0], Range("[1;5]"))
278	jonathan	896	eq(result, (1, 0, 24, [(4, .2), (9, .4), (14, .6), (19, .8), (24, 1.0)]))
279	jonathan	890
280			if __name__ == "__main__":
281			unittest.main()
282
Name	Value
svn:eol-style	native
svn:keywords	Author Date Id Revision