示例#1
0
    def setUp(self):
        self.h = Distribution((0.0, 5.0))
        self.h.add({0: 0.0})
        self.h.add({1: 0.1})
        self.h.add({2: 0.2})
        self.h.add({2: 0.2})
        self.h.add({3: 0.3})
        self.h.add({3: 0.3})
        self.h.add({3: 0.3})
        self.h.add({4: 0.4})
        self.h.add({4: 0.4})
        self.h.add({4: 0.4})
        self.h.add({4: 0.4})
        self.h.add({5: 0.5})
        self.h.add({5: 0.5})
        self.h.add({5: 0.5})
        self.h.add({5: 0.5})
        self.h.add({5: 0.5})

        self.g = copy.deepcopy(self.h)
        self.g.add({0: 0.0})
        self.g.add({1: 0.1})
        self.g.add({2: 0.2})
        self.g.add({3: 0.3})
        self.g.add({4: 0.4})
        self.g.add({5: 0.5})
示例#2
0
    def test_statistics(self):

        self.a = Distribution(cyclic=True)
        self.a.add({0.0:0.0, pi/2:1.0})
        self.assertAlmostEqual(vector_sum( self.a )[0], 1.0)
        self.assertAlmostEqual(weighted_average( self.a ), pi/2)
        self.assertAlmostEqual(vector_sum( self.a )[1], weighted_average( self.a ))
        self.assertAlmostEqual(selectivity( self.a ), 1.0)

        self.a.add({-pi/2:1.0}) # (should be like 3pi/2)
        self.assertAlmostEqual(vector_sum( self.a )[0], 0.0)
        self.assertAlmostEqual(weighted_average( self.a ), 0.0)
        self.assertAlmostEqual(selectivity( self.a ), 0.0)

        self.a.add({3*pi/8:0.3})
        self.assertAlmostEqual(vector_sum( self.a )[0], 0.3)
        self.assertAlmostEqual(weighted_average( self.a ), 3*pi/8)
        self.assertAlmostEqual(selectivity( self.a ), vector_sum( self.a )[0]/2.3)

        self.c = Distribution((0.0,1.0), cyclic=True)
        self.c.add({0.0:1.0, 0.25:1.0})
        self.assertAlmostEqual(vector_sum( self.c )[0], (1.0+1.0)**0.5) 
        self.assertAlmostEqual(weighted_average( self.c ), vector_sum( self.c )[1])
        self.assertEqual(vector_sum( self.c )[1], atan2(1.0,1.0)/(2*pi))

        self.c.add({1.75:1.0})  # added beyond bounds
        self.assertAlmostEqual(vector_sum( self.c )[0], 1.0) 
        self.assertEqual(weighted_average( self.c ), 0.0)

        
        self.d = Distribution(axis_bounds=(0.0,1.0),cyclic=False,keep_peak=False)
        self.assertEqual(self.d.undefined_vals, 0)
        self.assertAlmostEqual(selectivity( self.d ), 1.0)

        self.d.add({0.0: 0.0})
        self.assertAlmostEqual(selectivity( self.d ), 1.0)
        self.d.add({0.5: 0.0})
        self.assertAlmostEqual(selectivity( self.d ), 0.0)
        # note that selectivity() actually includes a call to DSF_WeightedAverage
        self.assertEqual(self.d.undefined_vals, 4)


        self.assertAlmostEqual(weighted_average( self.d ),0.0)
        self.assertEqual(self.d.undefined_vals, 6)
        
        self.d.add({0.0: 1.0})
        self.assertAlmostEqual(selectivity( self.d ), 1.0)
        self.assertEqual(self.d.undefined_vals, 6)
        
        self.d.add({0.5: 1.0})
        self.assertAlmostEqual(selectivity( self.d ), 0.0)

        self.d.add({0.75: 2.0})
        self.assertAlmostEqual(selectivity( self.d ), 0.25) 
    def test_statistics(self):

        self.a = Distribution(cyclic=True)
        self.a.add({0.0:0.0, pi/2:1.0})
        self.assertAlmostEqual(self.a.vector_sum()[0], 1.0)
        self.assertAlmostEqual(self.a.weighted_average(), pi/2)
        self.assertAlmostEqual(self.a.vector_sum()[1], self.a.weighted_average())
        self.assertAlmostEqual(self.a.selectivity(), 1.0)

        self.a.add({-pi/2:1.0}) # (should be like 3pi/2)
        self.assertAlmostEqual(self.a.vector_sum()[0], 0.0)
        self.assertAlmostEqual(self.a.weighted_average(), 0.0)
        self.assertAlmostEqual(self.a.selectivity(), 0.0)

        self.a.add({3*pi/8:0.3})
        self.assertAlmostEqual(self.a.vector_sum()[0], 0.3)
        self.assertAlmostEqual(self.a.weighted_average(), 3*pi/8)
        self.assertAlmostEqual(self.a.selectivity(), self.a.vector_sum()[0]/2.3)

        self.c = Distribution((0.0,1.0), cyclic=True)
        self.c.add({0.0:1.0, 0.25:1.0})
        self.assertAlmostEqual(self.c.vector_sum()[0], (1.0+1.0)**0.5) 
        self.assertAlmostEqual(self.c.weighted_average(), self.c.vector_sum()[1])
        self.assertEqual(self.c.vector_sum()[1], atan2(1.0,1.0)/(2*pi))

        self.c.add({1.75:1.0})  # added beyond bounds
        self.assertAlmostEqual(self.c.vector_sum()[0], 1.0) 
        self.assertEqual(self.c.weighted_average(), 0.0)

        
        self.d = Distribution(axis_bounds=(0.0,1.0),cyclic=False,keep_peak=False)
        self.assertEqual(self.d.undefined_vals, 0)
        self.assertAlmostEqual(self.d.selectivity(), 1.0)

        self.d.add({0.0: 0.0})
        self.assertAlmostEqual(self.d.selectivity(), 1.0)
        self.d.add({0.5: 0.0})
        self.assertAlmostEqual(self.d.selectivity(), 0.0)
        self.assertEqual(self.d.undefined_vals, 1)


        self.assertAlmostEqual(self.d.weighted_average(),0.0)
        self.assertEqual(self.d.undefined_vals, 2)
        
        self.d.add({0.0: 1.0})
        self.assertAlmostEqual(self.d.selectivity(), 1.0)
        self.assertEqual(self.d.undefined_vals, 2)
        
        self.d.add({0.5: 1.0})
        self.assertAlmostEqual(self.d.selectivity(), 0.0)

        self.d.add({0.75: 2.0})
        self.assertAlmostEqual(self.d.selectivity(), 0.25) 
示例#4
0
 def setUp(self):
     self.h = Distribution((0.0,5.0))
     self.h.add({0:0.0})
     self.h.add({1:0.1})
     self.h.add({2:0.2})
     self.h.add({2:0.2})
     self.h.add({3:0.3})
     self.h.add({3:0.3})
     self.h.add({3:0.3})
     self.h.add({4:0.4})
     self.h.add({4:0.4})
     self.h.add({4:0.4})
     self.h.add({4:0.4})
     self.h.add({5:0.5})
     self.h.add({5:0.5})
     self.h.add({5:0.5})
     self.h.add({5:0.5})
     self.h.add({5:0.5})
     
     self.g = copy.deepcopy(self.h)
     self.g.add({0:0.0})
     self.g.add({1:0.1})
     self.g.add({2:0.2})
     self.g.add({3:0.3})
     self.g.add({4:0.4})
     self.g.add({5:0.5})
示例#5
0
    def test_lissom_peak_histogram(self):
        self.p = Distribution((0, 2), keep_peak=True)

        self.p.add({0: 1.0})
        self.p.add({2: 9.9})
        self.p.add({2: 3.3})
        self.p.add({0: 1.0})
        self.p.add({1: 0.3})
        self.p.add({1: 84.0})
        self.p.add({1: 36.0})

        self.assertAlmostEqual(self.p.get_value(0), 1.0)
        self.assertAlmostEqual(self.p.get_value(1), 84.0)
        self.assertAlmostEqual(self.p.get_value(2), 9.9)

        self.assertEqual(self.p.get_count(0), 2)
        self.assertEqual(self.p.get_count(1), 3)
        self.assertEqual(self.p.get_count(2), 2)
示例#6
0
    def test_lissom_statistics(self):
        self.assertEqual(len(self.h.values()), 6)
        self.assertAlmostEqual(self.h.total_value, 5.5)
        self.assertEqual(self.h.total_count, 16)

        self.assertAlmostEqual(max(self.h.values()), 2.5)
        self.assertAlmostEqual(min(self.h.values()), 0.0)
        self.assertEqual(max(self.h.counts()), 5)
        self.assertEqual(min(self.h.counts()), 1)

        self.assertAlmostEqual(self.g.total_value, 7.0)
        self.assertEqual(self.g.total_count, 22)
        self.assertAlmostEqual(sum(self.g.values()), 7.0)

        self.assertAlmostEqual(self.g.weighted_sum(), 28.0)
        # (should return _weighted_average:)
        self.assertAlmostEqual(weighted_average(self.g),
                               28.0 / sum(self.g.values()))
        self.assertAlmostEqual(vector_sum(self.g)[1], 4.40449904283)

        self.q = Distribution((0, 4), cyclic=True)
        self.q.add({3: 1})
        self.q.add({0: 0, 1: 0, 2: 0, 4: 0})
        self.assertAlmostEqual(vector_sum(self.q)[0], 1.0)
        self.assertAlmostEqual(weighted_average(self.q), 3.0)
        self.assertAlmostEqual(vector_sum(self.q)[1], 3.0)

        # Example where this matches LISSOM by using an empty bin at 5.
        self.rr = Distribution(
            (0, 5), cyclic=True
        )  # 5 because in the L. test example 0 and 4 are distinct
        self.rr.add({0: 1, 1: 1, 2: 1, 3: 1, 4: 1})

        self.assertAlmostEqual(vector_sum(self.rr)[0], 0.0)
        self.assertAlmostEqual(weighted_average(self.rr),
                               vector_sum(self.rr)[1])
        self.rr.add({1: 2})
        self.assertAlmostEqual(vector_sum(self.rr)[0], 2.0)
        self.assertAlmostEqual(weighted_average(self.rr), 1.0)
        self.rr.add({3: 2})
        self.assertAlmostEqual(vector_sum(self.rr)[0], 2 * 2 * cos(2 * pi / 5))
        self.assertAlmostEqual(weighted_average(self.rr), 2.0)
示例#7
0
    def test_lissom_statistics(self):
        self.assertEqual(len(self.h.values()), 6)
        self.assertAlmostEqual(self.h.total_value, 5.5)
        self.assertEqual(self.h.total_count, 16)
        
        self.assertAlmostEqual(max(self.h.values()), 2.5)
        self.assertAlmostEqual(min(self.h.values()), 0.0)
        self.assertEqual(max(self.h.counts()), 5)
        self.assertEqual(min(self.h.counts()), 1)

        
        self.assertAlmostEqual(self.g.total_value, 7.0)         
        self.assertEqual(self.g.total_count, 22)
        self.assertAlmostEqual(sum(self.g.values()), 7.0)

        self.assertAlmostEqual(self.g.weighted_sum(), 28.0)
        # (should return _weighted_average:)
        self.assertAlmostEqual( weighted_average( self.g ), 28.0/sum(self.g.values()))
        self.assertAlmostEqual(vector_sum( self.g )[1], 4.40449904283) 


        self.q = Distribution((0,4), cyclic=True)
        self.q.add({3:1})
        self.q.add({0:0, 1:0, 2:0, 4:0})                
        self.assertAlmostEqual(vector_sum( self.q )[0], 1.0)
        self.assertAlmostEqual(weighted_average( self.q ), 3.0)
        self.assertAlmostEqual(vector_sum( self.q )[1], 3.0)  

        # Example where this matches LISSOM by using an empty bin at 5.
        self.rr = Distribution((0,5), cyclic=True)  # 5 because in the L. test example 0 and 4 are distinct
        self.rr.add({0:1, 1:1, 2:1, 3:1, 4:1})
        
        self.assertAlmostEqual(vector_sum( self.rr )[0], 0.0)
        self.assertAlmostEqual(weighted_average( self.rr ), vector_sum( self.rr )[1])
        self.rr.add({1:2})
        self.assertAlmostEqual(vector_sum( self.rr )[0], 2.0) 
        self.assertAlmostEqual(weighted_average( self.rr ), 1.0)  
        self.rr.add({3:2})
        self.assertAlmostEqual(vector_sum( self.rr )[0], 2*2*cos(2*pi/5)) 
        self.assertAlmostEqual(weighted_average( self.rr ), 2.0)
示例#8
0
    def test_statistics(self):

        self.a = Distribution(cyclic=True)
        self.a.add({0.0: 0.0, pi / 2: 1.0})
        self.assertAlmostEqual(vector_sum(self.a)[0], 1.0)
        self.assertAlmostEqual(weighted_average(self.a), pi / 2)
        self.assertAlmostEqual(vector_sum(self.a)[1], weighted_average(self.a))
        self.assertAlmostEqual(selectivity(self.a), 1.0)

        self.a.add({-pi / 2: 1.0})  # (should be like 3pi/2)
        self.assertAlmostEqual(vector_sum(self.a)[0], 0.0)
        self.assertAlmostEqual(weighted_average(self.a), 0.0)
        self.assertAlmostEqual(selectivity(self.a), 0.0)

        self.a.add({3 * pi / 8: 0.3})
        self.assertAlmostEqual(vector_sum(self.a)[0], 0.3)
        self.assertAlmostEqual(weighted_average(self.a), 3 * pi / 8)
        self.assertAlmostEqual(selectivity(self.a),
                               vector_sum(self.a)[0] / 2.3)

        self.c = Distribution((0.0, 1.0), cyclic=True)
        self.c.add({0.0: 1.0, 0.25: 1.0})
        self.assertAlmostEqual(vector_sum(self.c)[0], (1.0 + 1.0)**0.5)
        self.assertAlmostEqual(weighted_average(self.c), vector_sum(self.c)[1])
        self.assertEqual(vector_sum(self.c)[1], atan2(1.0, 1.0) / (2 * pi))

        self.c.add({1.75: 1.0})  # added beyond bounds
        self.assertAlmostEqual(vector_sum(self.c)[0], 1.0)
        self.assertEqual(weighted_average(self.c), 0.0)

        self.d = Distribution(axis_bounds=(0.0, 1.0),
                              cyclic=False,
                              keep_peak=False)
        self.assertEqual(self.d.undefined_vals, 0)
        self.assertAlmostEqual(selectivity(self.d), 1.0)

        self.d.add({0.0: 0.0})
        self.assertAlmostEqual(selectivity(self.d), 1.0)
        self.d.add({0.5: 0.0})
        self.assertAlmostEqual(selectivity(self.d), 0.0)
        # note that selectivity() actually includes a call to DSF_WeightedAverage
        self.assertEqual(self.d.undefined_vals, 4)

        self.assertAlmostEqual(weighted_average(self.d), 0.0)
        self.assertEqual(self.d.undefined_vals, 6)

        self.d.add({0.0: 1.0})
        self.assertAlmostEqual(selectivity(self.d), 1.0)
        self.assertEqual(self.d.undefined_vals, 6)

        self.d.add({0.5: 1.0})
        self.assertAlmostEqual(selectivity(self.d), 0.0)

        self.d.add({0.75: 2.0})
        self.assertAlmostEqual(selectivity(self.d), 0.25)
示例#9
0
    def test_lissom_peak_histogram(self):
        self.p = Distribution((0,2),keep_peak=True)

        self.p.add({0:1.0})
        self.p.add({2:9.9})
        self.p.add({2:3.3})
        self.p.add({0:1.0})
        self.p.add({1:0.3})
        self.p.add({1:84.0})
        self.p.add({1:36.0})

        self.assertAlmostEqual(self.p.get_value(0), 1.0)
        self.assertAlmostEqual(self.p.get_value(1), 84.0)
        self.assertAlmostEqual(self.p.get_value(2), 9.9)

        self.assertEqual(self.p.get_count(0), 2)
        self.assertEqual(self.p.get_count(1), 3)
        self.assertEqual(self.p.get_count(2), 2)
示例#10
0
class TestDistribution(unittest.TestCase):
    def setUp(self):
        self.h = Distribution((0.0, 5.0))
        self.h.add({0: 0.0})
        self.h.add({1: 0.1})
        self.h.add({2: 0.2})
        self.h.add({2: 0.2})
        self.h.add({3: 0.3})
        self.h.add({3: 0.3})
        self.h.add({3: 0.3})
        self.h.add({4: 0.4})
        self.h.add({4: 0.4})
        self.h.add({4: 0.4})
        self.h.add({4: 0.4})
        self.h.add({5: 0.5})
        self.h.add({5: 0.5})
        self.h.add({5: 0.5})
        self.h.add({5: 0.5})
        self.h.add({5: 0.5})

        self.g = copy.deepcopy(self.h)
        self.g.add({0: 0.0})
        self.g.add({1: 0.1})
        self.g.add({2: 0.2})
        self.g.add({3: 0.3})
        self.g.add({4: 0.4})
        self.g.add({5: 0.5})

    def test_raise_errors(self):
        self.assertRaises(ValueError, self.h.add, {6: 1.0})

    def test_lissom_values(self):
        self.assertAlmostEqual(self.h.get_value(0), 0.0)
        self.assertAlmostEqual(self.h.get_value(1), 0.1)
        self.assertAlmostEqual(self.h.get_value(2), 0.4)
        self.assertAlmostEqual(self.h.get_value(3), 0.9)
        self.assertAlmostEqual(self.h.get_value(4), 1.6)
        self.assertAlmostEqual(self.h.get_value(5), 2.5)

        self.assertEqual(self.h.get_count(0), 1)
        self.assertEqual(self.h.get_count(1), 1)
        self.assertEqual(self.h.get_count(2), 2)
        self.assertEqual(self.h.get_count(3), 3)
        self.assertEqual(self.h.get_count(4), 4)
        self.assertEqual(self.h.get_count(5), 5)

        self.assertAlmostEqual(self.g.get_value(0), 0.0)
        self.assertAlmostEqual(self.g.get_value(1), 0.2)
        self.assertAlmostEqual(self.g.get_value(2), 0.6)
        self.assertAlmostEqual(self.g.get_value(3), 1.2)
        self.assertAlmostEqual(self.g.get_value(4), 2.0)
        self.assertAlmostEqual(self.g.get_value(5), 3.0)

    def test_lissom_mags(self):
        self.assertAlmostEqual(self.h.value_mag(0), 0.0 / 5.5)
        self.assertAlmostEqual(self.h.value_mag(1), 0.1 / 5.5)
        self.assertAlmostEqual(self.h.value_mag(2), 0.4 / 5.5)
        self.assertAlmostEqual(self.h.value_mag(3), 0.9 / 5.5)
        self.assertAlmostEqual(self.h.value_mag(4), 1.6 / 5.5)
        self.assertAlmostEqual(self.h.value_mag(5), 2.5 / 5.5)

        self.assertAlmostEqual(self.h.count_mag(0), 1.0 / 16)
        self.assertAlmostEqual(self.h.count_mag(1), 1.0 / 16)
        self.assertAlmostEqual(self.h.count_mag(2), 2.0 / 16)
        self.assertAlmostEqual(self.h.count_mag(3), 3.0 / 16)
        self.assertAlmostEqual(self.h.count_mag(4), 4.0 / 16)
        self.assertAlmostEqual(self.h.count_mag(5), 5.0 / 16)

    def test_lissom_statistics(self):
        self.assertEqual(len(self.h.values()), 6)
        self.assertAlmostEqual(self.h.total_value, 5.5)
        self.assertEqual(self.h.total_count, 16)

        self.assertAlmostEqual(max(self.h.values()), 2.5)
        self.assertAlmostEqual(min(self.h.values()), 0.0)
        self.assertEqual(max(self.h.counts()), 5)
        self.assertEqual(min(self.h.counts()), 1)

        self.assertAlmostEqual(self.g.total_value, 7.0)
        self.assertEqual(self.g.total_count, 22)
        self.assertAlmostEqual(sum(self.g.values()), 7.0)

        self.assertAlmostEqual(self.g.weighted_sum(), 28.0)
        # (should return _weighted_average:)
        self.assertAlmostEqual(weighted_average(self.g),
                               28.0 / sum(self.g.values()))
        self.assertAlmostEqual(vector_sum(self.g)[1], 4.40449904283)

        self.q = Distribution((0, 4), cyclic=True)
        self.q.add({3: 1})
        self.q.add({0: 0, 1: 0, 2: 0, 4: 0})
        self.assertAlmostEqual(vector_sum(self.q)[0], 1.0)
        self.assertAlmostEqual(weighted_average(self.q), 3.0)
        self.assertAlmostEqual(vector_sum(self.q)[1], 3.0)

        # Example where this matches LISSOM by using an empty bin at 5.
        self.rr = Distribution(
            (0, 5), cyclic=True
        )  # 5 because in the L. test example 0 and 4 are distinct
        self.rr.add({0: 1, 1: 1, 2: 1, 3: 1, 4: 1})

        self.assertAlmostEqual(vector_sum(self.rr)[0], 0.0)
        self.assertAlmostEqual(weighted_average(self.rr),
                               vector_sum(self.rr)[1])
        self.rr.add({1: 2})
        self.assertAlmostEqual(vector_sum(self.rr)[0], 2.0)
        self.assertAlmostEqual(weighted_average(self.rr), 1.0)
        self.rr.add({3: 2})
        self.assertAlmostEqual(vector_sum(self.rr)[0], 2 * 2 * cos(2 * pi / 5))
        self.assertAlmostEqual(weighted_average(self.rr), 2.0)

    def test_lissom_peak_histogram(self):
        self.p = Distribution((0, 2), keep_peak=True)

        self.p.add({0: 1.0})
        self.p.add({2: 9.9})
        self.p.add({2: 3.3})
        self.p.add({0: 1.0})
        self.p.add({1: 0.3})
        self.p.add({1: 84.0})
        self.p.add({1: 36.0})

        self.assertAlmostEqual(self.p.get_value(0), 1.0)
        self.assertAlmostEqual(self.p.get_value(1), 84.0)
        self.assertAlmostEqual(self.p.get_value(2), 9.9)

        self.assertEqual(self.p.get_count(0), 2)
        self.assertEqual(self.p.get_count(1), 3)
        self.assertEqual(self.p.get_count(2), 2)

    def test_statistics(self):

        self.a = Distribution(cyclic=True)
        self.a.add({0.0: 0.0, pi / 2: 1.0})
        self.assertAlmostEqual(vector_sum(self.a)[0], 1.0)
        self.assertAlmostEqual(weighted_average(self.a), pi / 2)
        self.assertAlmostEqual(vector_sum(self.a)[1], weighted_average(self.a))
        self.assertAlmostEqual(selectivity(self.a), 1.0)

        self.a.add({-pi / 2: 1.0})  # (should be like 3pi/2)
        self.assertAlmostEqual(vector_sum(self.a)[0], 0.0)
        self.assertAlmostEqual(weighted_average(self.a), 0.0)
        self.assertAlmostEqual(selectivity(self.a), 0.0)

        self.a.add({3 * pi / 8: 0.3})
        self.assertAlmostEqual(vector_sum(self.a)[0], 0.3)
        self.assertAlmostEqual(weighted_average(self.a), 3 * pi / 8)
        self.assertAlmostEqual(selectivity(self.a),
                               vector_sum(self.a)[0] / 2.3)

        self.c = Distribution((0.0, 1.0), cyclic=True)
        self.c.add({0.0: 1.0, 0.25: 1.0})
        self.assertAlmostEqual(vector_sum(self.c)[0], (1.0 + 1.0)**0.5)
        self.assertAlmostEqual(weighted_average(self.c), vector_sum(self.c)[1])
        self.assertEqual(vector_sum(self.c)[1], atan2(1.0, 1.0) / (2 * pi))

        self.c.add({1.75: 1.0})  # added beyond bounds
        self.assertAlmostEqual(vector_sum(self.c)[0], 1.0)
        self.assertEqual(weighted_average(self.c), 0.0)

        self.d = Distribution(axis_bounds=(0.0, 1.0),
                              cyclic=False,
                              keep_peak=False)
        self.assertEqual(self.d.undefined_vals, 0)
        self.assertAlmostEqual(selectivity(self.d), 1.0)

        self.d.add({0.0: 0.0})
        self.assertAlmostEqual(selectivity(self.d), 1.0)
        self.d.add({0.5: 0.0})
        self.assertAlmostEqual(selectivity(self.d), 0.0)
        # note that selectivity() actually includes a call to DSF_WeightedAverage
        self.assertEqual(self.d.undefined_vals, 4)

        self.assertAlmostEqual(weighted_average(self.d), 0.0)
        self.assertEqual(self.d.undefined_vals, 6)

        self.d.add({0.0: 1.0})
        self.assertAlmostEqual(selectivity(self.d), 1.0)
        self.assertEqual(self.d.undefined_vals, 6)

        self.d.add({0.5: 1.0})
        self.assertAlmostEqual(selectivity(self.d), 0.0)

        self.d.add({0.75: 2.0})
        self.assertAlmostEqual(selectivity(self.d), 0.25)
示例#11
0
class TestDistribution(unittest.TestCase):

    def setUp(self):
        self.h = Distribution((0.0,5.0))
        self.h.add({0:0.0})
        self.h.add({1:0.1})
        self.h.add({2:0.2})
        self.h.add({2:0.2})
        self.h.add({3:0.3})
        self.h.add({3:0.3})
        self.h.add({3:0.3})
        self.h.add({4:0.4})
        self.h.add({4:0.4})
        self.h.add({4:0.4})
        self.h.add({4:0.4})
        self.h.add({5:0.5})
        self.h.add({5:0.5})
        self.h.add({5:0.5})
        self.h.add({5:0.5})
        self.h.add({5:0.5})
        
        self.g = copy.deepcopy(self.h)
        self.g.add({0:0.0})
        self.g.add({1:0.1})
        self.g.add({2:0.2})
        self.g.add({3:0.3})
        self.g.add({4:0.4})
        self.g.add({5:0.5})


    def test_raise_errors(self):
        self.assertRaises(ValueError, self.h.add, {6:1.0})


    def test_lissom_values(self):
        self.assertAlmostEqual(self.h.get_value(0), 0.0)
        self.assertAlmostEqual(self.h.get_value(1), 0.1)
        self.assertAlmostEqual(self.h.get_value(2), 0.4)
        self.assertAlmostEqual(self.h.get_value(3), 0.9)
        self.assertAlmostEqual(self.h.get_value(4), 1.6)
        self.assertAlmostEqual(self.h.get_value(5), 2.5)

        self.assertEqual(self.h.get_count(0), 1)
        self.assertEqual(self.h.get_count(1), 1)
        self.assertEqual(self.h.get_count(2), 2)
        self.assertEqual(self.h.get_count(3), 3)
        self.assertEqual(self.h.get_count(4), 4)
        self.assertEqual(self.h.get_count(5), 5)

        self.assertAlmostEqual(self.g.get_value(0), 0.0)
        self.assertAlmostEqual(self.g.get_value(1), 0.2)
        self.assertAlmostEqual(self.g.get_value(2), 0.6)
        self.assertAlmostEqual(self.g.get_value(3), 1.2)
        self.assertAlmostEqual(self.g.get_value(4), 2.0)
        self.assertAlmostEqual(self.g.get_value(5), 3.0)
        

    def test_lissom_mags(self):
        self.assertAlmostEqual(self.h.value_mag(0), 0.0/5.5)
        self.assertAlmostEqual(self.h.value_mag(1), 0.1/5.5)
        self.assertAlmostEqual(self.h.value_mag(2), 0.4/5.5)
        self.assertAlmostEqual(self.h.value_mag(3), 0.9/5.5)
        self.assertAlmostEqual(self.h.value_mag(4), 1.6/5.5)
        self.assertAlmostEqual(self.h.value_mag(5), 2.5/5.5)

        self.assertAlmostEqual(self.h.count_mag(0), 1.0/16)
        self.assertAlmostEqual(self.h.count_mag(1), 1.0/16)
        self.assertAlmostEqual(self.h.count_mag(2), 2.0/16)
        self.assertAlmostEqual(self.h.count_mag(3), 3.0/16)
        self.assertAlmostEqual(self.h.count_mag(4), 4.0/16)
        self.assertAlmostEqual(self.h.count_mag(5), 5.0/16)

   
    def test_lissom_statistics(self):
        self.assertEqual(len(self.h.values()), 6)
        self.assertAlmostEqual(self.h.total_value, 5.5)
        self.assertEqual(self.h.total_count, 16)
        
        self.assertAlmostEqual(max(self.h.values()), 2.5)
        self.assertAlmostEqual(min(self.h.values()), 0.0)
        self.assertEqual(max(self.h.counts()), 5)
        self.assertEqual(min(self.h.counts()), 1)

        
        self.assertAlmostEqual(self.g.total_value, 7.0)         
        self.assertEqual(self.g.total_count, 22)
        self.assertAlmostEqual(sum(self.g.values()), 7.0)

        self.assertAlmostEqual(self.g.weighted_sum(), 28.0)
        # (should return _weighted_average:)
        self.assertAlmostEqual( weighted_average( self.g ), 28.0/sum(self.g.values()))
        self.assertAlmostEqual(vector_sum( self.g )[1], 4.40449904283) 


        self.q = Distribution((0,4), cyclic=True)
        self.q.add({3:1})
        self.q.add({0:0, 1:0, 2:0, 4:0})                
        self.assertAlmostEqual(vector_sum( self.q )[0], 1.0)
        self.assertAlmostEqual(weighted_average( self.q ), 3.0)
        self.assertAlmostEqual(vector_sum( self.q )[1], 3.0)  

        # Example where this matches LISSOM by using an empty bin at 5.
        self.rr = Distribution((0,5), cyclic=True)  # 5 because in the L. test example 0 and 4 are distinct
        self.rr.add({0:1, 1:1, 2:1, 3:1, 4:1})
        
        self.assertAlmostEqual(vector_sum( self.rr )[0], 0.0)
        self.assertAlmostEqual(weighted_average( self.rr ), vector_sum( self.rr )[1])
        self.rr.add({1:2})
        self.assertAlmostEqual(vector_sum( self.rr )[0], 2.0) 
        self.assertAlmostEqual(weighted_average( self.rr ), 1.0)  
        self.rr.add({3:2})
        self.assertAlmostEqual(vector_sum( self.rr )[0], 2*2*cos(2*pi/5)) 
        self.assertAlmostEqual(weighted_average( self.rr ), 2.0)




    def test_lissom_peak_histogram(self):
        self.p = Distribution((0,2),keep_peak=True)

        self.p.add({0:1.0})
        self.p.add({2:9.9})
        self.p.add({2:3.3})
        self.p.add({0:1.0})
        self.p.add({1:0.3})
        self.p.add({1:84.0})
        self.p.add({1:36.0})

        self.assertAlmostEqual(self.p.get_value(0), 1.0)
        self.assertAlmostEqual(self.p.get_value(1), 84.0)
        self.assertAlmostEqual(self.p.get_value(2), 9.9)

        self.assertEqual(self.p.get_count(0), 2)
        self.assertEqual(self.p.get_count(1), 3)
        self.assertEqual(self.p.get_count(2), 2)



    def test_statistics(self):

        self.a = Distribution(cyclic=True)
        self.a.add({0.0:0.0, pi/2:1.0})
        self.assertAlmostEqual(vector_sum( self.a )[0], 1.0)
        self.assertAlmostEqual(weighted_average( self.a ), pi/2)
        self.assertAlmostEqual(vector_sum( self.a )[1], weighted_average( self.a ))
        self.assertAlmostEqual(selectivity( self.a ), 1.0)

        self.a.add({-pi/2:1.0}) # (should be like 3pi/2)
        self.assertAlmostEqual(vector_sum( self.a )[0], 0.0)
        self.assertAlmostEqual(weighted_average( self.a ), 0.0)
        self.assertAlmostEqual(selectivity( self.a ), 0.0)

        self.a.add({3*pi/8:0.3})
        self.assertAlmostEqual(vector_sum( self.a )[0], 0.3)
        self.assertAlmostEqual(weighted_average( self.a ), 3*pi/8)
        self.assertAlmostEqual(selectivity( self.a ), vector_sum( self.a )[0]/2.3)

        self.c = Distribution((0.0,1.0), cyclic=True)
        self.c.add({0.0:1.0, 0.25:1.0})
        self.assertAlmostEqual(vector_sum( self.c )[0], (1.0+1.0)**0.5) 
        self.assertAlmostEqual(weighted_average( self.c ), vector_sum( self.c )[1])
        self.assertEqual(vector_sum( self.c )[1], atan2(1.0,1.0)/(2*pi))

        self.c.add({1.75:1.0})  # added beyond bounds
        self.assertAlmostEqual(vector_sum( self.c )[0], 1.0) 
        self.assertEqual(weighted_average( self.c ), 0.0)

        
        self.d = Distribution(axis_bounds=(0.0,1.0),cyclic=False,keep_peak=False)
        self.assertEqual(self.d.undefined_vals, 0)
        self.assertAlmostEqual(selectivity( self.d ), 1.0)

        self.d.add({0.0: 0.0})
        self.assertAlmostEqual(selectivity( self.d ), 1.0)
        self.d.add({0.5: 0.0})
        self.assertAlmostEqual(selectivity( self.d ), 0.0)
        # note that selectivity() actually includes a call to DSF_WeightedAverage
        self.assertEqual(self.d.undefined_vals, 4)


        self.assertAlmostEqual(weighted_average( self.d ),0.0)
        self.assertEqual(self.d.undefined_vals, 6)
        
        self.d.add({0.0: 1.0})
        self.assertAlmostEqual(selectivity( self.d ), 1.0)
        self.assertEqual(self.d.undefined_vals, 6)
        
        self.d.add({0.5: 1.0})
        self.assertAlmostEqual(selectivity( self.d ), 0.0)

        self.d.add({0.75: 2.0})
        self.assertAlmostEqual(selectivity( self.d ), 0.25)