Add evaluate: bool argument to math parser

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(