示例#1
0
    def test_negation_increasing_activation_out_of_range(self):
        activator = activators.LinearActivator(zeroActivationValue=0,
                                               fullActivationValue=10,
                                               minActivation=0,
                                               maxActivation=1)

        mock_sensor = sensors.Sensor(initial_value=12)

        condition = conditions.Condition(sensor=mock_sensor,
                                         activator=activator)

        neg_condition = conditions.Negation(condition)

        neg_condition.updateComputation()

        con_satisfaction = condition.satisfaction
        neg_con_satisfaction = neg_condition.satisfaction

        self.assertAlmostEqual(con_satisfaction, 1.0, places=3)
        self.assertAlmostEqual(neg_con_satisfaction, 0.0, places=3)

        con_wish = condition.getWishes()[0]
        neg_con_wish = neg_condition.getWishes()[0]

        self.assertAlmostEqual(con_wish.indicator, 0.0, places=3)
        self.assertAlmostEqual(neg_con_wish.indicator, -1.0, places=3)
示例#2
0
    def test_negation_decreasing_activation(self):
        activator = activators.LinearActivator(zeroActivationValue=10,
                                               fullActivationValue=0,
                                               minActivation=0,
                                               maxActivation=1)

        mock_sensor = sensors.Sensor(initial_value=3)

        condition = activators.Condition(sensor=mock_sensor,
                                         activator=activator)

        neg_condition = conditions.Negation(condition)

        neg_condition.updateComputation()

        con_satisfaction = condition.satisfaction
        neg_con_satisfaction = neg_condition.satisfaction

        self.assertAlmostEqual(con_satisfaction, 0.7, places=3)
        self.assertAlmostEqual(neg_con_satisfaction, 0.3, places=3)

        con_wish, con_wish_value = condition.getWishes()[0]
        neg_con_wish, neg_con_wish_value = neg_condition.getWishes()[0]

        self.assertAlmostEqual(con_wish_value, -0.3, places=3)
        self.assertAlmostEqual(neg_con_wish_value, 0.7, places=3)
示例#3
0
 def test_pddl_function_name_restoring(self):
     activator_name = 'MyFamousActivator'
     activator_example = activators.LinearActivator(name=activator_name,
                                                    zeroActivationValue=0,
                                                    fullActivationValue=1)
     sensor_name = 'my_sensor'
     function_name = activator_example.getPDDLFunctionName(sensor_name)
     restored_name = Activator.restore_condition_name_from_pddl_function_name(
         pddl_function_name=function_name, sensor_name=sensor_name)
     self.assertEqual(activator_name,
                      restored_name,
                      msg='Activator name and restored name are not equal')
示例#4
0
    def test_increasing_range_out_of_max_activation_range_(self):
        activator = activators.LinearActivator(zeroActivationValue=5,
                                               fullActivationValue=10,
                                               minActivation=0,
                                               maxActivation=1)
        sensor_value = 12

        activation = activator.computeActivation(sensor_value)
        self.assertEqual(activation, 1)

        wish = activator.getSensorWish(sensor_value)
        self.assertEqual(wish, 0)
示例#5
0
    def test_decreasing_range_small_activation2(self):
        activator = activators.LinearActivator(zeroActivationValue=10,
                                               fullActivationValue=5,
                                               minActivation=0,
                                               maxActivation=1)

        sensor_value = 9

        activation = activator.computeActivation(sensor_value)
        self.assertEqual(activation, 0.2)

        wish = activator.getSensorWish(sensor_value)
        self.assertEqual(wish, -0.8)
示例#6
0
    def test_increasing_range_large_activation(self):
        activator = activators.LinearActivator(zeroActivationValue=0,
                                               fullActivationValue=10,
                                               minActivation=0,
                                               maxActivation=1)

        sensor_value = 9

        activation = activator.computeActivation(sensor_value)
        self.assertEqual(activation, 0.9)

        wish = activator.getSensorWish(sensor_value)
        self.assertEqual(wish, 0.1)