Add evaluate: bool argument to math parser (#365)

So far, when math expressions were parsed, they were evaluated as far as possible.
This was not always desirable.

Now, this optional as far as conveniently possible.

Closes #363.

Author: dweindl

petab/v1/math/SympyVisitor.py

@@ -39,8 +39,12 @@
 }
 _unary_funcs = {
     "exp": sp.exp,
-    "log10": lambda x: -sp.oo if x.is_zero is True else sp.log(x, 10),
-    "log2": lambda x: -sp.oo if x.is_zero is True else sp.log(x, 2),
+    "log10": lambda x, evaluate=True: -sp.oo
+    if x.is_zero is True
+    else sp.log(x, 10, evaluate=evaluate),
+    "log2": lambda x, evaluate=True: -sp.oo
+    if x.is_zero is True
+    else sp.log(x, 2, evaluate=evaluate),
     "ln": sp.log,
     "sqrt": sp.sqrt,
     "abs": sp.Abs,
@@ -75,8 +79,14 @@ class MathVisitorSympy(PetabMathExprParserVisitor):
 
     For a general introduction to ANTLR4 visitors, see:
     https://github.com/antlr/antlr4/blob/7d4cea92bc3f7d709f09c3f1ac77c5bbc71a6749/doc/python-target.md
+
+    :param evaluate: Whether to evaluate the expression.
     """
 
+    def __init__(self, evaluate=True):
+        super().__init__()
+        self.evaluate = evaluate
+
     def visitPetabExpression(
         self, ctx: PetabMathExprParser.PetabExpressionContext
     ) -> sp.Expr | sp.Basic:
@@ -101,9 +111,17 @@ def visitMultExpr(
             operand1 = bool2num(self.visit(ctx.getChild(0)))
             operand2 = bool2num(self.visit(ctx.getChild(2)))
             if ctx.ASTERISK():
-                return operand1 * operand2
+                return sp.Mul(operand1, operand2, evaluate=self.evaluate)
             if ctx.SLASH():
-                return operand1 / operand2
+                return (
+                    operand1 / operand2
+                    if self.evaluate
+                    else sp.Mul(
+                        operand1,
+                        sp.Pow(operand2, -1, evaluate=False),
+                        evaluate=False,
+                    )
+                )
 
         raise AssertionError(f"Unexpected expression: {ctx.getText()}")
 
@@ -112,9 +130,9 @@ def visitAddExpr(self, ctx: PetabMathExprParser.AddExprContext) -> sp.Expr:
         op1 = bool2num(self.visit(ctx.getChild(0)))
         op2 = bool2num(self.visit(ctx.getChild(2)))
         if ctx.PLUS():
-            return op1 + op2
+            return sp.Add(op1, op2, evaluate=self.evaluate)
         if ctx.MINUS():
-            return op1 - op2
+            return sp.Add(op1, -op2, evaluate=self.evaluate)
 
         raise AssertionError(
             f"Unexpected operator: {ctx.getChild(1).getText()} "
@@ -146,28 +164,32 @@ def visitFunctionCall(
                     f"Unexpected number of arguments: {len(args)} "
                     f"in {ctx.getText()}"
                 )
-            return _trig_funcs[func_name](*args)
+            return _trig_funcs[func_name](*args, evaluate=self.evaluate)
         if func_name in _unary_funcs:
             if len(args) != 1:
                 raise AssertionError(
                     f"Unexpected number of arguments: {len(args)} "
                     f"in {ctx.getText()}"
                 )
-            return _unary_funcs[func_name](*args)
+            return _unary_funcs[func_name](*args, evaluate=self.evaluate)
         if func_name in _binary_funcs:
             if len(args) != 2:
                 raise AssertionError(
                     f"Unexpected number of arguments: {len(args)} "
                     f"in {ctx.getText()}"
                 )
-            return _binary_funcs[func_name](*args)
+            return _binary_funcs[func_name](*args, evaluate=self.evaluate)
         if func_name == "log":
             if len(args) not in [1, 2]:
                 raise AssertionError(
                     f"Unexpected number of arguments: {len(args)} "
                     f"in {ctx.getText()}"
                 )
-            return -sp.oo if args[0].is_zero is True else sp.log(*args)
+            return (
+                -sp.oo
+                if args[0].is_zero is True
+                else sp.log(*args, evaluate=self.evaluate)
+            )
 
         if func_name == "piecewise":
             if (len(args) - 1) % 2 != 0:
@@ -184,7 +206,7 @@ def visitFunctionCall(
                     args[::2], args[1::2], strict=True
                 )
             )
-            return sp.Piecewise(*sp_args)
+            return sp.Piecewise(*sp_args, evaluate=self.evaluate)
 
         raise ValueError(f"Unknown function: {ctx.getText()}")
 
@@ -203,7 +225,7 @@ def visitPowerExpr(
             )
         operand1 = bool2num(self.visit(ctx.getChild(0)))
         operand2 = bool2num(self.visit(ctx.getChild(2)))
-        return sp.Pow(operand1, operand2)
+        return sp.Pow(operand1, operand2, evaluate=self.evaluate)
 
     def visitUnaryExpr(
         self, ctx: PetabMathExprParser.UnaryExprContext
@@ -240,7 +262,7 @@ def visitComparisonExpr(
         if op in ops:
             lhs = bool2num(lhs)
             rhs = bool2num(rhs)
-            return ops[op](lhs, rhs)
+            return ops[op](lhs, rhs, evaluate=self.evaluate)
 
         raise AssertionError(f"Unexpected operator: {op}")
 
@@ -301,4 +323,6 @@ def num2bool(x: sp.Basic | sp.Expr) -> sp.Basic | sp.Expr:
         return sp.false
     if x.is_zero is False:
         return sp.true
+    if isinstance(x, Boolean):
+        return x
     return sp.Piecewise((True, x != 0.0), (False, True))

petab/v1/math/sympify.py

@@ -12,7 +12,9 @@
 __all__ = ["sympify_petab"]
 
 
-def sympify_petab(expr: str | int | float) -> sp.Expr | sp.Basic:
+def sympify_petab(
+    expr: str | int | float, evaluate: bool = True
+) -> sp.Expr | sp.Basic:
     """Convert PEtab math expression to sympy expression.
 
     .. note::
@@ -22,6 +24,7 @@ def sympify_petab(expr: str | int | float) -> sp.Expr | sp.Basic:
 
     Args:
         expr: PEtab math expression.
+        evaluate: Whether to evaluate the expression.
 
     Raises:
         ValueError: Upon lexer/parser errors or if the expression is
@@ -30,6 +33,33 @@ def sympify_petab(expr: str | int | float) -> sp.Expr | sp.Basic:
     Returns:
         The sympy expression corresponding to `expr`.
         Boolean values are converted to numeric values.
+
+
+    :example:
+    >>> from petab.math import sympify_petab
+    >>> sympify_petab("sin(0)")
+    0
+    >>> sympify_petab("sin(0)", evaluate=False)
+    sin(0.0)
+    >>> sympify_petab("sin(0)", evaluate=True)
+    0
+    >>> sympify_petab("1 + 2", evaluate=True)
+    3.00000000000000
+    >>> sympify_petab("1 + 2", evaluate=False)
+    1.0 + 2.0
+    >>> sympify_petab("piecewise(1, 1 > 2, 0)", evaluate=True)
+    0.0
+    >>> sympify_petab("piecewise(1, 1 > 2, 0)", evaluate=False)
+    Piecewise((1.0, 1.0 > 2.0), (0.0, True))
+    >>> # currently, boolean values are converted to numeric values
+    >>> #  independent of the `evaluate` flag
+    >>> sympify_petab("true", evaluate=True)
+    1.00000000000000
+    >>> sympify_petab("true", evaluate=False)
+    1.00000000000000
+    >>> # ... and integer values are converted to floats
+    >>> sympify_petab("2", evaluate=True)
+    2.00000000000000
     """
     if isinstance(expr, sp.Expr):
         # TODO: check if only PEtab-compatible symbols and functions are used
@@ -62,7 +92,7 @@ def sympify_petab(expr: str | int | float) -> sp.Expr | sp.Basic:
         raise ValueError(f"Error parsing {expr!r}: {e.args[0]}") from None
 
     # Convert to sympy expression
-    visitor = MathVisitorSympy()
+    visitor = MathVisitorSympy(evaluate=evaluate)
     expr = visitor.visit(tree)
     expr = bool2num(expr)
     # check for `False`, we'll accept both `True` and `None`

tests/v1/math/test_math.py

@@ -24,6 +24,11 @@ def test_parse_simple():
     assert float(sympify_petab("1 + 2 * (3 + 4) / 2")) == 8
 
 
+def test_evaluate():
+    act = sympify_petab("piecewise(1, 1 > 2, 0)", evaluate=False)
+    assert str(act) == "Piecewise((1.0, 1.0 > 2.0), (0.0, True))"
+
+
 def read_cases():
     """Read test cases from YAML file in the petab_test_suite package."""
     yaml_file = importlib.resources.files("petabtests.cases").joinpath(