Adding continuous effects to durative actions

docs/problem_representation.rst

@@ -111,6 +111,15 @@ Problem Kinds
    * -
      - DECREASE_EFFECTS
      - At least one effect uses the numeric decrement operator.
+   * -
+     - INCREASE_CONTINUOUS_EFFECTS
+     - At least one effect uses the continuous numeric increment operator.
+   * -
+     - DECREASE_CONTINUOUS_EFFECTS
+     - At least one effect uses the continuous numeric decrement operator.
+   * -
+     - NON_LINEAR_CONTINUOUS_EFFECTS
+     - At least one continuous effect is described by a differential equation that depends on a continuous variable.
    * -
      - STATIC_FLUENTS_IN_BOOLEAN_ASSIGNMENTS
      - At least one effect uses a static fluent in the expression of a boolean assignment.

unified_planning/io/pddl_reader.py

@@ -54,6 +54,10 @@
         if len(self.value) == 1 and isinstance(self.value[0], str):
             self.value = self.value[0]
 
+    def __iter__(self):
+        for i in range(len(self)):
+            yield self[i]
+
     def __getitem__(self, i):
         return CustomParseResults(self.value[i])
 
@@ -72,6 +76,20 @@
     def col_end(self, complete_str: str) -> int:
         return col(self.locn_end, complete_str)
 
+    def __contains__(self, string: str):
+        stack = [self]
+        while len(stack) > 0:
+            exp = stack.pop()
+            if isinstance(exp.value, str):
+                if exp.value == string:
+                    return True
+            elif isinstance(exp.value, ParseResults):
+                for e in exp:
+                    stack.append(e)
+            else:
+                raise SyntaxError(f"Not able to handle: {exp}")
+        return False
+
 
 Object = "object"
 TypesMap = Dict[str, unified_planning.model.Type]
@@ -101,7 +119,7 @@
             + ":requirements"
             + OneOrMore(
                 one_of(
-                    ":strips :typing :negative-preconditions :disjunctive-preconditions :equality :existential-preconditions :universal-preconditions :quantified-preconditions :conditional-effects :fluents :numeric-fluents :adl :durative-actions :duration-inequalities :timed-initial-literals :timed-initial-effects :action-costs :hierarchy :method-preconditions :constraints :contingent :preferences"
+                    ":strips :typing :negative-preconditions :disjunctive-preconditions :equality :existential-preconditions :universal-preconditions :quantified-preconditions :conditional-effects :fluents :numeric-fluents :adl :durative-actions :duration-inequalities :timed-initial-literals :timed-initial-effects :action-costs :hierarchy :method-preconditions :constraints :contingent :preferences :continuous-effects"
                 )
             )
             + Suppress(")")
@@ -564,7 +582,9 @@
         exp: CustomParseResults,
         complete_str: str,
         cond: Union[up.model.FNode, bool] = True,
-        timing: typing.Optional[up.model.Timing] = None,
+        timing: typing.Optional[
+            Union[up.model.Timing, up.model.timing.TimeInterval]
+        ] = None,
         forall_variables: typing.Optional[Dict[str, up.model.Variable]] = None,
     ):
         if forall_variables is None:
@@ -610,27 +630,199 @@
                 )
                 act.add_effect(*eff if timing is None else (timing, *eff), forall=tuple(forall_variables.values()))  # type: ignore
             elif op == "increase":
-                eff = (
-                    self._parse_exp(
-                        problem, act, types_map, forall_variables, exp[1], complete_str
-                    ),
-                    self._parse_exp(
-                        problem, act, types_map, forall_variables, exp[2], complete_str
-                    ),
-                    cond,
-                )
-                act.add_increase_effect(*eff if timing is None else (timing, *eff))  # type: ignore
+                if "#t" in exp:
+                    if (
+                        len(exp) == 3
+                        and len(exp[2]) == 3
+                        and exp[2][0].value == "*"
+                        and exp[2][1].value == "#t"
+                    ):
+                        eff = (
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[1],
+                                complete_str,
+                            ),
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[2][2],
+                                complete_str,
+                            ),
+                            cond,
+                        )
+                        assert isinstance(timing, up.model.TimeInterval)
+                        assert isinstance(act, up.model.DurativeAction)
+                        act.add_increase_continuous_effect(timing, *eff)
+                    elif (
+                        len(exp) == 3
+                        and len(exp[2]) == 3
+                        and exp[2][0].value == "*"
+                        and exp[2][2].value == "#t"
+                    ):
+                        eff_inverted = (
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[1],
+                                complete_str,
+                            ),
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[2][1],
+                                complete_str,
+                            ),
+                            cond,
+                        )
+                        assert isinstance(timing, up.model.TimeInterval)
+                        assert isinstance(act, up.model.DurativeAction)
+                        act.add_increase_continuous_effect(timing, *eff_inverted)
+                    elif len(exp) == 3 and exp[2].value == "#t":
+                        eff_without = (
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[1],
+                                complete_str,
+                            ),
+                            1,
+                            cond,
+                        )
+                        assert isinstance(timing, up.model.TimeInterval)
+                        assert isinstance(act, up.model.DurativeAction)
+                        act.add_increase_continuous_effect(timing, *eff_without)
+                    else:
+                        raise SyntaxError("Continuous change syntax is not correct!")
+                else:
+                    eff = (
+                        self._parse_exp(
+                            problem,
+                            act,
+                            types_map,
+                            forall_variables,
+                            exp[1],
+                            complete_str,
+                        ),
+                        self._parse_exp(
+                            problem,
+                            act,
+                            types_map,
+                            forall_variables,
+                            exp[2],
+                            complete_str,
+                        ),
+                        cond,
+                    )
+                    act.add_increase_effect(*eff if timing is None else (timing, *eff))  # type: ignore
             elif op == "decrease":
-                eff = (
-                    self._parse_exp(
-                        problem, act, types_map, forall_variables, exp[1], complete_str
-                    ),
-                    self._parse_exp(
-                        problem, act, types_map, forall_variables, exp[2], complete_str
-                    ),
-                    cond,
-                )
-                act.add_decrease_effect(*eff if timing is None else (timing, *eff))  # type: ignore
+                if "#t" in exp:
+                    if (
+                        len(exp) == 3
+                        and len(exp[2]) == 3
+                        and exp[2][0].value == "*"
+                        and exp[2][1].value == "#t"
+                    ):
+                        eff_inverted = (
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[1],
+                                complete_str,
+                            ),
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[2][2],
+                                complete_str,
+                            ),
+                            cond,
+                        )
+                        assert isinstance(timing, up.model.TimeInterval)
+                        assert isinstance(act, up.model.DurativeAction)
+                        act.add_decrease_continuous_effect(timing, *eff_inverted)
+                    elif (
+                        len(exp) == 3
+                        and len(exp[2]) == 3
+                        and exp[2][0].value == "*"
+                        and exp[2][2].value == "#t"
+                    ):
+                        eff = (
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[1],
+                                complete_str,
+                            ),
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[2][1],
+                                complete_str,
+                            ),
+                            cond,
+                        )
+                        assert isinstance(timing, up.model.TimeInterval)
+                        assert isinstance(act, up.model.DurativeAction)
+                        act.add_decrease_continuous_effect(timing, *eff)
+                    elif len(exp) == 3 and exp[2].value == "#t":
+                        eff_without = (
+                            self._parse_exp(
+                                problem,
+                                act,
+                                types_map,
+                                forall_variables,
+                                exp[1],
+                                complete_str,
+                            ),
+                            1,
+                            cond,
+                        )
+                        assert isinstance(timing, up.model.TimeInterval)
+                        assert isinstance(act, up.model.DurativeAction)
+                        act.add_decrease_continuous_effect(timing, *eff_without)
+                    else:
+                        raise SyntaxError("Continuous change syntax is not correct!")
+                else:
+                    eff = (
+                        self._parse_exp(
+                            problem,
+                            act,
+                            types_map,
+                            forall_variables,
+                            exp[1],
+                            complete_str,
+                        ),
+                        self._parse_exp(
+                            problem,
+                            act,
+                            types_map,
+                            forall_variables,
+                            exp[2],
+                            complete_str,
+                        ),
+                        cond,
+                    )
+                    act.add_decrease_effect(*eff if timing is None else (timing, *eff))  # type: ignore
             elif op == "forall":
                 assert isinstance(exp, CustomParseResults)
                 if forall_variables:
@@ -774,7 +966,7 @@
                         eff[1][2],
                         complete_str,
                     )
-                    if len(eff[2]) == 3 and eff[2][1].value == "start":
+                    if len(eff[2]) == 3 and not "#t" in eff[2] and "start" in eff[2]:
                         self._add_effect(
                             problem,
                             act,
@@ -785,6 +977,20 @@
                             timing=up.model.StartTiming(),
                             forall_variables=forall_variables,
                         )
+                    elif "#t" in eff[2]:
+                        self._add_effect(
+                            problem,
+                            act,
+                            types_map,
+                            eff[2],
+                            complete_str,
+                            cond,
+                            timing=up.model.timing.ClosedTimeInterval(
+                                up.model.timing.StartTiming(),
+                                up.model.timing.EndTiming(),
+                            ),
+                            forall_variables=forall_variables,
+                        )
                     else:
                         raise UPUnsupportedProblemTypeError(
                             "Conditional effects with different timing are not supported."
@@ -802,7 +1008,7 @@
                         eff[1][2],
                         complete_str,
                     )
-                    if len(eff[2]) == 3 and eff[2][1].value == "end":
+                    if len(eff[2]) == 3 and "end" in eff[2]:
                         self._add_effect(
                             problem,
                             act,
@@ -841,6 +1047,18 @@
                     timing=up.model.EndTiming(),
                     forall_variables=forall_variables,
                 )
+            elif "#t" in eff:
+                self._add_effect(
+                    problem,
+                    act,
+                    types_map,
+                    eff,
+                    complete_str,
+                    timing=up.model.timing.ClosedTimeInterval(
+                        up.model.timing.StartTiming(), up.model.timing.EndTiming()
+                    ),
+                    forall_variables=forall_variables,
+                )
             elif len(eff) == 3 and op == "forall":
                 assert isinstance(eff, CustomParseResults)
                 if forall_variables: