def test_get_difference_percentage(self):
     '''
     Tests the get_difference_percentage method of the Calculator class.
     '''
     self.assertEqual(0.0, Calculator.get_difference_percentage(0.0, 0.0))
     self.assertEqual(50.0, Calculator.get_difference_percentage(1.0, 2.0))
     self.assertEqual(80.0, Calculator.get_difference_percentage(10.0, 2.0))
 def test_is_in_radius(self):
     '''
     Tests the is_in_radius method of the Calculator class.
     '''
     self.assertEqual(1, Calculator.is_in_radius(2, 4, 5, 3, 4))
     self.assertEqual(0, Calculator.is_in_radius(2, 4, 5, 3, 2))
     self.assertEqual(1, Calculator.is_in_radius(2, 2, 0, 1, 1))
     self.assertEqual(0, Calculator.is_in_radius(2, 2, 0, 1, 0)) 
    def test_calculate_expected_learning(self):
        '''
        Tests the calculate_expected_learning method of Calculator
        class using torus distance for calculating market and
        knowledge distance and parabola distance for distance between
        agents.
        '''
        # FOR  BETA = 6, MAP = 20
        self.assertAlmostEquals(0.0, \
          Calculator.calculate_expected_learning(2.0, 2.0, 1.0, 1.0, 1.0, 9.0))
        self.assertAlmostEquals(0.0, \
          Calculator.calculate_expected_learning(2.0, 2.0, 1.0, 1.0, 9.0, 1.0))

        # distances are the same for the following two examples
        # testing the torus shape for distance calculations.
        self.assertAlmostEquals(10.0, \
          Calculator.calculate_expected_learning(2.0, 2.0, 1.0, 1.0, 4.0, 4.0))
        self.assertAlmostEquals(10.0, \
          Calculator.calculate_expected_learning(2.0, 2.0, 1.0, 1.0, 18.0, 18.0))
    def test_calculate_next_position(self):
        '''
        Tests the calculate_next_position method of Calculator class.
        '''
        alpha = 0.05
        test_map = 20.0
        
        self.assertEqual(1, \
             Calculator.calculate_next_position(1.0, 9.0, \
                                                test_map, alpha, 2.0))

        self.assertAlmostEqual(1.08333, \
             Calculator.calculate_next_position(1.0, 4.0, \
                                                test_map, alpha, 2.0), \
                               places=5)

        # testing the torus points 2 and 19
        self.assertAlmostEqual(1.916666, \
              Calculator.calculate_next_position(2.0, 19.0, \
                                                 test_map, alpha, 2.0), \
                               places=5)
 def test_init_matrix(self):
     '''
     Tests the init_matrix method of the Calculator class.
     '''
     matrix = Calculator.init_matrix(3, 1)
     self.assertEqual(1, matrix[0][0])
     self.assertEqual(1, matrix[0][1])
     self.assertEqual(1, matrix[0][2])
     self.assertEqual(1, matrix[1][0])
     self.assertEqual(1, matrix[1][1])
     self.assertEqual(1, matrix[1][2])
     self.assertEqual(1, matrix[2][0])
     self.assertEqual(1, matrix[2][1])
     self.assertEqual(1, matrix[2][2])
 def test_reset_row_column(self):
     '''
     Tests the reset_row_column method of the Calculator class.
     '''
     matrix = [[1, 2, 3, 6] , [2, 4, 5, 4], [5, 7, 9, 3], [6, 3, 9, 1]]
     Calculator.reset_row_column(0, 2, matrix)
     # Tests the row and column values for index1
     self.assertEqual(0, matrix[0][0])
     self.assertEqual(0, matrix[0][1])
     self.assertEqual(0, matrix[0][2])
     self.assertEqual(0, matrix[0][3])
     self.assertEqual(0, matrix[1][0])
     self.assertEqual(0, matrix[2][0])
     self.assertEqual(0, matrix[3][0])
     
     # Tests the row and column values for index2
     self.assertEqual(0, matrix[2][0])
     self.assertEqual(0, matrix[2][1])
     self.assertEqual(0, matrix[2][2])
     self.assertEqual(0, matrix[2][3])
     self.assertEqual(0, matrix[0][2])
     self.assertEqual(0, matrix[1][2])
     self.assertEqual(0, matrix[2][2])
     self.assertEqual(0, matrix[3][2])
 def test_get_torus_distance(self):
     '''
     Tests the get_torus_distance method of Calculator class.
     FOR MAP = 20
     '''
     self.assertEqual(3.0, Calculator.get_torus_distance(2.0, 5.0, 10.0))
     self.assertEqual(4.0, Calculator.get_torus_distance(8.0, 2.0, 10.0))
     self.assertEqual(5.0, Calculator.get_torus_distance(0.0, 5.0, 10.0))
     self.assertEqual(5.0, Calculator.get_torus_distance(1.0, 6.0, 10.0))
     self.assertEqual(0.0, Calculator.get_torus_distance(10.0, 10.0, 10.0))
     self.assertEqual(0, Calculator.get_torus_distance(10.0, 0.0, 10.0))
 def test_is_in_torus_radius(self):
     '''
     Tests the is_in_radius method of the Calculator.
     '''
     # Tests the values also valid for 2D map.
     self.assertEqual(1, \
                      Calculator.is_in_torus_radius(2, 4, 5, 3, 4, 10, 10))
     self.assertEqual(0, \
                      Calculator.is_in_torus_radius(2, 4, 5, 3, 2, 10, 10))
     self.assertEqual(1, \
                      Calculator.is_in_torus_radius(2, 2, 0, 1, 1, 10, 10))
     self.assertEqual(0, \
                      Calculator.is_in_torus_radius(2, 2, 0, 1, 0, 10, 10))
     
     # Tests the values valid only on torus
     self.assertEqual(1, \
                   Calculator.is_in_torus_radius(1, 10, 1, 1, 2, 10, 10))
     self.assertEqual(1, \
                   Calculator.is_in_torus_radius(1, 10, 1, 10, 2, 10, 10))
     self.assertEqual(1, \
                   Calculator.is_in_torus_radius(0, 10, 10, 0, 2, 10, 10))
     self.assertEqual(1,
                   Calculator.is_in_torus_radius(3, 3, 10, 1, 2, 10, 10))
 def test_parabola_distance(self):
     '''
     Tests the parabola_distance method of Calculator class.
     '''
     self.assertAlmostEqual(((BETA * 4.0) - 16), \
                            Calculator.parabola_distance(5.0, 1.0))
 def test_rayleigh_distance(self):
     '''
     Tests the rayleigh_distance method of Calculator class.
     '''
     self.assertAlmostEqual(5 * exp(-25.0 / 2.0), \
                            Calculator.rayleigh_distance(5.0, 1.0))