Merge pull request #58 from ourstudio-se/57-add-a-test-for-default-prio-as-given-below

Added test for multiple defaults and a new evaluate function

Author: znittzel

puan/__init__.py

@@ -45,6 +45,12 @@ class Bounds:
     lower: int = default_min_int
     upper: int = default_max_int
 
+    def __init__(self, lower: int, upper: int):
+        if lower > upper:
+            raise ValueError(f"upper bound must be higher than lower bound, got: ({lower}, {upper})")
+        self.lower = lower
+        self.upper = upper
+
     def __iter__(self):
         return iter([self.lower, self.upper])
 

puan/logic/plog/__init__.py

@@ -196,7 +196,8 @@ def flatten(self) -> list:
 
             Examples
             --------
-                >>> proposition = AtLeast(1, [AtLeast(1, ["a", "b"], "B"), AtLeast(1, ["c", "d"], "C"), "e"], "A")
+                >>> proposition = AtLeast(1, [AtLeast(1, ["a", "b"], "B"),
+                ... AtLeast(1, ["c", "d"], "C"), "e"], "A")
                 >>> proposition.flatten()
                 [A: +(B,C,e)>=1, B: +(a,b)>=1, C: +(c,d)>=1, variable(id='a', bounds=Bounds(lower=0, upper=1)), variable(id='b', bounds=Bounds(lower=0, upper=1)), variable(id='c', bounds=Bounds(lower=0, upper=1)), variable(id='d', bounds=Bounds(lower=0, upper=1)), variable(id='e', bounds=Bounds(lower=0, upper=1))]
         """
@@ -515,6 +516,7 @@ def is_contradiction(self) -> bool:
                 >>> model = AtMost(-1,["x","y"])
                 >>> model.is_contradiction
                 True
+            
 
             Returns
             -------
@@ -523,60 +525,118 @@ def is_contradiction(self) -> bool:
         # When the highest sum from equation still not satisfied inequality, this is a contradition
         return self.equation_bounds[1] < 0
 
-    def evaluate(self, interpretation: typing.List[puan.SolutionVariable]) -> bool:
+    def evaluate(self, interpretation: typing.Dict[typing.Union[str, puan.variable], int]) -> bool:
 
         """
             Evaluates interpretation on this model. It will evaluate sub propositions
             bottoms-up and propagate results upwards. This means that even though 
             intermediate variables are not set in interpretation, they receive a value
             based on the evaluation of its propositions.
 
+            Parameters
+            ----------
+                interpretation: typing.Dict[typing.Union[str, puan.variable], int]
+                    the values of the variables in the model to evaluate it for
+
             Examples
             --------
-                >>> All(*"xy", variable="A").evaluate([puan.SolutionVariable("x", value=1)])
+                >>> All(*"xy", variable="A").evaluate({"x": 1})
                 False
 
-                >>> All(*"xy", variable="A").evaluate([puan.SolutionVariable("x", value=1), puan.SolutionVariable("y", value=1)])
+                >>> All(*"xy", variable="A").evaluate(
+                ... {puan.variable("x"): 1, puan.variable("y"): 1})
                 True
 
-                >>> AtLeast(propositions=[puan.variable("x", dtype="int")], value=10).evaluate([puan.SolutionVariable("x", value=9)])
+                >>> AtLeast(propositions=[puan.variable("x", dtype="int")],
+                ... value=10).evaluate({puan.variable("x"): 9})
                 False
 
-                >>> AtLeast(propositions=[puan.variable("x", dtype="int")], value=10).evaluate([puan.SolutionVariable("x", value=10)])
+                >>> AtLeast(propositions=[puan.variable("x", dtype="int")],
+                ... value=10).evaluate({puan.variable("x"): 10})
                 True
+            
+            See also
+            --------
+                evaluate_propositions      : Evaluates propositions on this model given a dict with variables and their values.
+            
+            Returns
+            -------
+                bool
         """
 
-        interpretation_map = dict(
-            zip(
-                map(
-                    operator.attrgetter("id"),
-                    interpretation
-                ),
-                map(
-                    operator.attrgetter("value"),
-                    interpretation
-                ),
-            )
-        )
+        return self.evaluate_propositions(interpretation)[self.variable.id] > 0
 
-        return (
-            sum(
-                map(
-                    lambda x: interpretation_map.get(x.id, 0)*self.sign if not type(x) == bool else x*1,
-                    itertools.chain(
-                        self.atomic_propositions,
-                        map(
-                            operator.methodcaller(
-                                "evaluate", 
-                                interpretation=interpretation,
-                            ),
-                            self.compound_propositions
+    def evaluate_propositions(self, interpretation: typing.Dict[typing.Union[str, puan.variable], int]) -> typing.Dict[typing.Union[str, puan.variable], int]:
+        """
+            Evaluates propositions on this model given a dict with variables and their values.
+
+            Parameters
+            ----------
+                interpretation: typing.Dict[typing.Union[str, puan.variable]
+                    the values of the variables in the model to evaluate it for
+            
+            Notes
+            -----
+            Bounds and dtypes of puan.variables in the interpretation are neglected, those values are only considered for the variables of the model.
+
+            A variable which is not included in the initial dict is calculated from its sub propositions or
+            defaulted to its lower bound (if variable doesn't have any subpropositions).
+
+            Examples
+            --------
+                >>> All(*"xy", variable="A").evaluate_propositions({"x": 1})
+                {'x': 1, 'y': 0, 'A': 0}
+
+                >>> All(*"xy", variable="A").evaluate_propositions({"x": 1, "y": 1})
+                {'x': 1, 'y': 1, 'A': 1}
+
+                >>> AtLeast(propositions=[puan.variable("x", dtype="int")],
+                ... value=10).evaluate_propositions({"x": 9})
+                {'x': 9, 'VARa6aef82726db5033e4b25e6fec8b5770cf89fe44ff8336731eef2bfa9a8ab35f': 0}
+
+                >>> AtLeast(propositions=[puan.variable("x", dtype="int")],
+                ... value=10).evaluate_propositions({"x": 10})
+                {'x': 10, 'VARa6aef82726db5033e4b25e6fec8b5770cf89fe44ff8336731eef2bfa9a8ab35f': 1}
+            
+            See also
+            --------
+                evaluate : Evaluates interpretation on this model.
+
+            Returns
+            -------
+                out : typing.Dict[typing.Union[str, puan.variable], int]
+        """
+        def _check_variable_in_bounds(id, val, bounds):
+            if val not in range(bounds.lower, bounds.upper+1):
+                raise ValueError("Variable {} is out of bounds, value: {}, bounds: {}".format(id, val, bounds))
+        def _get_variable_val(variable, interpretation):
+            if not variable in interpretation.keys():
+                interpretation[variable.id] = variable.bounds.lower
+            return interpretation
+        def _evaluate_propositions(prop, interpretation):
+            if not prop.variable.id in interpretation.keys():
+                # Calculate variable value and add to dict
+                val = sum(
+                            itertools.chain(
+                                map(
+                                    lambda x: _evaluate_propositions(x, interpretation)[x.id]*prop.sign,
+                                    prop.compound_propositions
+                                ),
+                                map(
+                                    lambda x: _get_variable_val(x, interpretation)[x.id]*prop.sign,
+                                    prop.atomic_propositions
+                                )
+                            )
                         )
+                _check_variable_in_bounds(prop.variable.id, 1*(val-prop.value >= 0), prop.variable.bounds)
+                interpretation[prop.variable.id] = 1*(
+                        val-prop.value >= 0
                     )
-                )
-            )-self.value
-        ) >= 0
-
+            return interpretation
+        interpretation_map = dict(map(lambda x: (x.id, x), filter(lambda x: type(x) == puan.variable, self.flatten())))
+        for x, y in filter(lambda x: x[0] in interpretation_map, interpretation.items()):
+                _check_variable_in_bounds(x, y, interpretation_map[x].bounds)
+        return _evaluate_propositions(self, interpretation)
 
     def to_short(self) -> tuple:
 

puan/ndarray/__init__.py

@@ -1170,33 +1170,38 @@ def row_distribution(self, row_index: int) -> numpy.ndarray:
             Column index 0 is a range from lowest to highest value of row equation. 
             Column index 1 is a counter of how many combinations, generated from variable bounds, evaluated into that value.
 
-            Example 1:
-            Equation = x+y+0
-            Result   = array([
-                [0, 1],
-                [1, 2],
-                [2, 1]
-            ])
-
-            2     |         <- 2 combinations ([1,0], [0,1]) results in value 1
-            1  |  |  |      <- 1 combination  ([0,0]) results in value 0 and 1 combination ([1,1]) results in value 2
-            0 ----------
-            0  1  2   
-
-            Example 2:
-            Equation = 2x+2y+0
-            Result   = array([
-                [0, 1],
-                [1, 0],
-                [2, 2],
-                [3, 0],
-                [4, 1]
-            ])
-
-            2        |   
-            1  |     |     |
-            0 ---------------
-            0  1  2  3  4
+        
+            .. code-block::
+                :caption: Example 1
+                
+                Equation = x+y+0
+                Result   = array([
+                    [0, 1],
+                    [1, 2],
+                    [2, 1]
+                ])
+
+                2     |         <- 2 combinations ([1,0], [0,1]) results in value 1
+                1  |  |  |      <- 1 combination  ([0,0]) results in value 0
+                  ----------       and 1 combination ([1,1]) results in value 2
+                   0  1  2   
+
+            .. code-block::
+                :caption: Example 2
+
+                Equation = 2x+2y+0
+                Result   = array([
+                    [0, 1],
+                    [1, 0],
+                    [2, 2],
+                    [3, 0],
+                    [4, 1]
+                ])
+
+                2        |   
+                1  |     |     |
+                  ---------------
+                   0  1  2  3  4
 
             Notes
             -----

tests/test_puan.py

@@ -36,8 +36,8 @@ def atom_proposition_strategy():
         puan.variable,
         id=st.text(), 
         bounds=st.tuples(
-            st.integers(min_value=-10, max_value=10),
-            st.integers(min_value=-10, max_value=10),
+            st.integers(min_value=-5, max_value=0),
+            st.integers(min_value=0, max_value=5),
         ),
     )
 
@@ -1670,6 +1670,56 @@ def test_not_when_single_str_or_variable():
     for entity in ["a", puan.variable("a")]:
         assert type(pg.Not(entity)) in [pg.All, pg.AtLeast]
 
+def test_multiple_defaults():
+    #a -> p ^ q (q)
+    #a -> p ^ r (r)
+    model = cc.StingyConfigurator(pg.All(pg.Imply("a", cc.Xor(*"pq", default="q")), pg.Imply("a", cc.Xor(*"pr", default="r"))))
+    config1 = {"a": 1, "p": 0, "q": 1, "r": 1}
+    config2 = {"a": 1, "p": 1}
+    full_config1 = model.evaluate_propositions(config1)
+    full_config2 = model.evaluate_propositions(config2)
+    keys1 = list(full_config1.keys())[:-1]
+    keys1.sort()
+    keys2 = list(full_config2.keys())[:-1]
+    keys2.sort()
+    int_ndarray1 = numpy.array(list(map(lambda x: full_config1[x], keys1)))
+    int_ndarray2 = numpy.array(list(map(lambda x: full_config2[x], keys2)))
+    objective_function = puan.ndarray.ndint_compress(model.polyhedron.default_prio_vector, method="shadow")
+    assert objective_function.dot(int_ndarray1) > objective_function.dot(int_ndarray2)
+
+def test_evaluate_propositions():
+    # Raises ValueError when configuration variable is out of bounds
+    with pytest.raises(ValueError):
+        pg.All(*"xy", variable="A").evaluate_propositions({"x": 3})
+    
+    # Unsatisfiable model
+    assert pg.AtLeast(2, "x").evaluate_propositions({"x": 0}) == {'VAR13c463c68a23bc633637b613e63e0025e2d498cf52ef76877ae6ed3475f4aba6': 0, "x": 0}
+
+    # Faulty configuration input
+    with pytest.raises(ValueError):
+        pg.All(*"xy", variable="A").evaluate_propositions({"x": "str"})
+
+    # Variable defaults to lower bounds when not given as configuration
+    assert pg.AtLeast(1, [puan.variable("x", bounds=(0,1))], variable="A").evaluate_propositions({}) == {"A": 0, "x": 0}
+    assert pg.AtLeast(1, [puan.variable("x", bounds=(1,10))], variable="A").evaluate_propositions({}) == {"A": 1, "x": 1}
+
+    # Puan.variable as input in configuration
+    assert pg.All(*"xy", variable="A").evaluate_propositions({puan.variable("x"): 1}) == {puan.variable(id='x', bounds=(0, 1)): 1, 'A': 0, 'y': 0}
+
+def configuration_dict_strategy():
+    return st.dictionaries(st.text(), st.integers(-2,2))
+
+@given(proposition_strategy(), configuration_dict_strategy())
+def test_propositions_evaluations(proposition, configuration):
+    value_error_raised = False
+    try:
+        evaluate_propositions_result = proposition.evaluate_propositions(configuration)[proposition.variable.id] > 0
+        evaluate_result = proposition.evaluate(configuration)
+    except ValueError:
+        value_error_raised = True
+    if not value_error_raised:
+        assert evaluate_propositions_result == evaluate_result
+            
 # def test_assuming_integer_variables():
 
 #     """
@@ -1764,7 +1814,7 @@ def test_bound_approx():
     ])
     assert (actual == expected).all()
 
-    # When a taighter bound exists
+    # When a tighter bound exists
     actual = puan.ndarray.ge_polyhedron([
         [ 3, 1, 0, 0, 0], # a_lb = 3
         [ 3, 0, 1, 0, 0], # a_lb = 3
@@ -2416,22 +2466,22 @@ def test_plog_evaluate_method():
         variable="fridge"
     )
 
-    cart = [
-        puan.SolutionVariable.from_variable(milk_home, 1),
-        puan.SolutionVariable.from_variable(milk_bought, 0),
-        puan.SolutionVariable.from_variable(tomatoes, 2+2),
-        puan.SolutionVariable.from_variable(cucumbers, 0),
-    ]
+    cart = {
+        milk_home: 1,
+        milk_bought: 0,
+        tomatoes: 2+2,
+        cucumbers: 0
+    }
 
     assert not fridge_model.evaluate(cart)
 
-    new_cart = [
-        puan.SolutionVariable.from_variable(chips, 1),
-        puan.SolutionVariable.from_variable(milk_home, 1),
-        puan.SolutionVariable.from_variable(milk_bought, 0),
-        puan.SolutionVariable.from_variable(tomatoes, 2+2),
-        puan.SolutionVariable.from_variable(cucumbers, 1),
-    ]
+    new_cart = {
+        chips: 1,
+        milk_home: 1,
+        milk_bought: 0,
+        tomatoes: 2+2,
+        cucumbers: 1
+    }
 
     assert fridge_model.evaluate(new_cart)