myokit 1.35.4__py3-none-any.whl → 1.36.1__py3-none-any.whl

myokit/formats/latex/_ewriter.py

@@ -20,19 +20,29 @@ class LatexExpressionWriter(myokit.formats.ExpressionWriter):
         self.set_time_variable_name()
 
         # Default lhs function
-        def fhls(lhs):
-            var = self._prepare_name(lhs.var().uname())
-            var = '\\text{' + var + '}'     # Depends on amsmath package!
-            if isinstance(lhs, myokit.Derivative):
-                var = '\\frac{d}{d\\text{t}}' + var
-            return var
+        def flhs(lhs):
+            v = r'\text{' + self._prepare_name(lhs.var().uname()) + '}'
+            if isinstance(lhs, myokit.Name):
+                return v
+            elif isinstance(lhs, myokit.Derivative):
+                return r'\frac{d' + v + r'}{d\text{' + self._time + '}}'
+            elif isinstance(lhs, myokit.PartialDerivative):
+                v2 = self._prepare_name(
+                    lhs.independent_expression().var().uname())
+                return r'\frac{\partial' + v + r'}{\partial\text{' + v2 + '}}'
+            elif isinstance(lhs, myokit.InitialValue):
+                return v + r'(\text{' + self._time + '} = 0)'
+            else:   # pragma: no cover
+                raise ValueError(f'Unsupported LHS type {type(lhs)}')
+
         self._flhs = None
-        self.set_lhs_function(fhls)
+        self.set_lhs_function(flhs)
 
     def set_lhs_function(self, f):
         """
         Sets a naming function, will be called to get the variable name from a
-         ``myokit.LhsExpression`` object.
+         :class:`myokit.LhsExpression`. This function is also responsible for
+         converting it to a suitable Latex form (e.g. adding `\\text{}`).
 
         The argument ``f`` should be a function that takes an ``LhsExpression``
         as input and returns a string.
@@ -40,31 +50,22 @@ class LatexExpressionWriter(myokit.formats.ExpressionWriter):
         self._flhs = f
 
     def set_time_variable_name(self, name='t'):
-        """
-        Sets a name to use for the time variable in derivatives
-        """
+        """ Sets a name to use for the time variable in derivatives. """
         self._time = self._prepare_name(name)
 
     def eq(self, eq):
-        """
-        Converts an equation to a string.
-        """
+        """ See :meth:`myokit.formats.ExpressionWriter.eq()`. """
         return self.ex(eq.lhs) + ' = ' + self.ex(eq.rhs)
 
     def ex(self, e):
-        """
-        Converts an expression to a string.
-        """
+        """ See :meth:`myokit.formats.ExpressionWriter.ex()`. """
         b = []
         self._ex(e, b)
         return ''.join(b)
 
     def _prepare_name(self, text):
-        """
-        Prepares a name for use in latex
-        """
-        text = str(text)
-        return text.replace('_', '\_')
+        """ Sanitises a name for use in latex. """
+        return str(text).replace('_', r'\_')
 
     def _ex(self, e, b):
         try:
@@ -73,40 +74,43 @@ class LatexExpressionWriter(myokit.formats.ExpressionWriter):
             raise ValueError('Unknown expression type: ' + str(type(e)))
         action(e, b)
 
+    def _ex_prefix(self, e, b, op):
+        """ Handles _ex() for prefix operators. """
+        b.append(op)
+        if e.bracket(e[0]):
+            b.append(r'\left(')
+        self._ex(e[0], b)
+        if e.bracket(e[0]):
+            b.append(r'\right)')
+
     def _ex_infix(self, e, b, op):
-        """
-        Handles _ex() for infix operators
-        """
+        """ Handles _ex() for infix operators. """
         if e.bracket(e[0]):
-            b.append('\\left(')
+            b.append(r'\left(')
         self._ex(e[0], b)
         if e.bracket(e[0]):
-            b.append('\\right)')
+            b.append(r'\right)')
         b.append(op)
         if e.bracket(e[1]):
-            b.append('\\left(')
+            b.append(r'\left(')
         self._ex(e[1], b)
         if e.bracket(e[1]):
-            b.append('\\right)')
+            b.append(r'\right)')
 
     def _ex_function(self, e, b, func):
-        """
-        Handles _ex() for function operators
-        """
+        """ Handles _ex() for function operators. """
         b.append(func)
-        b.append('\\left(')
+        b.append(r'\left(')
         b.append(','.join([self.ex(x) for x in e]))
-        b.append('\\right)')
+        b.append(r'\right)')
 
     def _ex_infix_condition(self, e, b, op):
-        """
-        Handles _ex() for infix condition operators
-        """
-        b.append('\\left(')
+        """ Handles _ex() for infix condition operators. """
+        b.append(r'\left(')
         self._ex(e[0], b)
         b.append(op)
         self._ex(e[1], b)
-        b.append('\\right)')
+        b.append(r'\right)')
 
     def _ex_name(self, e, b):
         b.append(self._flhs(e))
@@ -114,21 +118,24 @@ class LatexExpressionWriter(myokit.formats.ExpressionWriter):
     def _ex_derivative(self, e, b):
         b.append(self._flhs(e))
 
+    def _ex_partial_derivative(self, e, b):
+        b.append(self._flhs(e))
+
+    def _ex_initial_value(self, e, b):
+        b.append(self._flhs(e))
+
     def _ex_number(self, e, b):
-        b.append(myokit.float.str(e))
+        b.append(myokit.float.str(e).strip())
+        u = e.unit()
+        if u is not None and u is not myokit.units.dimensionless:
+            u = str(u)[1:-1]
+            b.append(r' \text{' + u + '}')
 
     def _ex_prefix_plus(self, e, b):
-        self._ex(e[0], b)
+        self._ex_prefix(e, b, '+')
 
     def _ex_prefix_minus(self, e, b):
-        b.append('\\left(')
-        b.append('-')
-        if e.bracket(e[0]):
-            b.append('\\left(')
-        self._ex(e[0], b)
-        if e.bracket(e[0]):
-            b.append('\\right)')
-        b.append('\\right)')
+        self._ex_prefix(e, b, '-')
 
     def _ex_plus(self, e, b):
         self._ex_infix(e, b, '+')
@@ -137,10 +144,10 @@ class LatexExpressionWriter(myokit.formats.ExpressionWriter):
         self._ex_infix(e, b, '-')
 
     def _ex_multiply(self, e, b):
-        self._ex_infix(e, b, '*')
+        self._ex_infix(e, b, r'\cdot')
 
     def _ex_divide(self, e, b):
-        b.append('\\frac{')
+        b.append(r'\frac{')
         self._ex(e[0], b)
         b.append('}{')
         self._ex(e[1], b)
@@ -149,85 +156,88 @@ class LatexExpressionWriter(myokit.formats.ExpressionWriter):
     def _ex_quotient(self, e, b):
         # Note: Quotient in myokit uses round-to-zero (like Python does!)
         # See: myokit.Quotient
-        b.append('\\left\\lfloor')
+        b.append(r'\left\lfloor')
         self._ex_divide(e, b)
-        b.append('\\right\\rfloor')
+        b.append(r'\right\rfloor')
 
     def _ex_remainder(self, e, b):
-        self._ex_function(e, b, '\\bmod')
+        self._ex_infix(e, b, r'\bmod')
 
     def _ex_power(self, e, b):
-        if e.bracket(e[0]):
-            b.append('\\left(')
+        if e.bracket(e[0]) or isinstance(e[0], myokit.Power):
+            b.append(r'\left(')
         self._ex(e[0], b)
-        if e.bracket(e[0]):
-            b.append('\\right)')
-        b.append('^{')
+        if e.bracket(e[0]) or isinstance(e[0], myokit.Power):
+            b.append(r'\right)')
+        b.append('^')
+        if e.bracket(e[1]) or isinstance(e[1], myokit.Power):
+            b.append('{')
         self._ex(e[1], b)
-        b.append('}')
+        if e.bracket(e[1]) or isinstance(e[1], myokit.Power):
+            b.append('}')
 
     def _ex_sqrt(self, e, b):
-        b.append('\\sqrt{')
+        b.append(r'\sqrt{')
         self._ex(e[0], b)
         b.append('}')
 
     def _ex_sin(self, e, b):
-        self._ex_function(e, b, '\\sin')
+        self._ex_function(e, b, r'\sin')
 
     def _ex_cos(self, e, b):
-        self._ex_function(e, b, '\\cos')
+        self._ex_function(e, b, r'\cos')
 
     def _ex_tan(self, e, b):
-        self._ex_function(e, b, '\\tan')
+        self._ex_function(e, b, r'\tan')
 
     def _ex_asin(self, e, b):
-        self._ex_function(e, b, '\\arcsin')
+        self._ex_function(e, b, r'\arcsin')
 
     def _ex_acos(self, e, b):
-        self._ex_function(e, b, '\\arccos')
+        self._ex_function(e, b, r'\arccos')
 
     def _ex_atan(self, e, b):
-        self._ex_function(e, b, '\\arctan')
+        self._ex_function(e, b, r'\arctan')
 
     def _ex_exp(self, e, b):
-        self._ex_function(e, b, '\\exp')
+        self._ex_function(e, b, r'\exp')
 
     def _ex_log(self, e, b):
-        b.append('\\log')
+        b.append(r'\log')
         if len(e) > 1:
             b.append('_{')
             self._ex(e[1], b)
             b.append('}')
-        b.append('\\left(')
+        b.append(r'\left(')
         self._ex(e[0], b)
-        b.append('\\right)')
+        b.append(r'\right)')
 
     def _ex_log10(self, e, b):
-        return self._ex_log(myokit.Log(e[0], myokit.Number(10)), b)
+        b.append(r'\log_{10}')
+        b.append(r'\left(')
+        self._ex(e[0], b)
+        b.append(r'\right)')
 
     def _ex_floor(self, e, b):
-        b.append('\\left\\lfloor{')
+        b.append(r'\left\lfloor{')
         self._ex(e[0], b)
-        b.append('}\\right\\rfloor')
+        b.append(r'}\right\rfloor')
 
     def _ex_ceil(self, e, b):
-        b.append('\\left\\lceil{')
+        b.append(r'\left\lceil{')
         self._ex(e[0], b)
-        b.append('}\\right\\rceil')
+        b.append(r'}\right\rceil')
 
     def _ex_abs(self, e, b):
-        b.append('\\lvert{')
+        b.append(r'\lvert{')
         self._ex(e[0], b)
-        b.append('}\\rvert')
-
-    def _ex_not(self, e, b):
-        self._ex_function(e, b, '\\not')
+        b.append(r'}\rvert')
 
     def _ex_equal(self, e, b):
         self._ex_infix_condition(e, b, '=')
 
     def _ex_not_equal(self, e, b):
-        self._ex_infix_condition(e, b, '\\neq')
+        self._ex_infix_condition(e, b, r'\neq')
 
     def _ex_more(self, e, b):
         self._ex_infix_condition(e, b, '>')
@@ -236,21 +246,26 @@ class LatexExpressionWriter(myokit.formats.ExpressionWriter):
         self._ex_infix_condition(e, b, '<')
 
     def _ex_more_equal(self, e, b):
-        self._ex_infix_condition(e, b, '\\geq')
+        self._ex_infix_condition(e, b, r'\geq')
 
     def _ex_less_equal(self, e, b):
-        self._ex_infix_condition(e, b, '\\leq')
+        self._ex_infix_condition(e, b, r'\leq')
+
+    def _ex_not(self, e, b):
+        b.append(r'\left(\not')
+        self._ex(e[0], b)
+        b.append(r'\right)')
 
     def _ex_and(self, e, b):
-        self._ex_infix_condition(e, b, '\\and')
+        self._ex_infix_condition(e, b, r'\and')
 
     def _ex_or(self, e, b):
-        self._ex_infix_condition(e, b, '\\or')
+        self._ex_infix_condition(e, b, r'\or')
 
     def _ex_if(self, e, b):
         # Not suported
-        self._ex_function(e, b, 'if')
+        self._ex_function(e, b, r'\text{if}')
 
     def _ex_piecewise(self, e, b):
         # Not suported
-        self._ex_function(e, b, 'piecewise')
+        self._ex_function(e, b, r'\text{piecewise}')

myokit/formats/latex/_exporter.py

@@ -23,7 +23,7 @@ class PdfExporter(myokit.formats.Exporter):
         """
         Cleans some text for use in latex.
         """
-        return text.replace('_', '\_')
+        return text.replace('_', r'\_')
 
     def post_export_info(self):
         return '\n'.join((

myokit/formats/mathml/_ewriter.py

@@ -130,11 +130,11 @@ class MathMLExpressionWriter(myokit.formats.ExpressionWriter):
         bra = e.bracket(e[0])
         if self._pres:
             row = etree.SubElement(t, 'mrow')
+            x = etree.SubElement(row, 'mo')
+            x.text = e.operator_rep()
             if bra:
                 x = etree.SubElement(row, 'mo')
                 x.text = '('
-            x = etree.SubElement(row, 'mo')
-            x.text = e.operator_rep()
             self._ex(e[0], row)
             if bra:
                 x = etree.SubElement(row, 'mo')

myokit/formats/matlab/_ewriter.py

@@ -4,6 +4,8 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
+import myokit
+
 from myokit.formats.python import PythonExpressionWriter
 
 
@@ -17,15 +19,32 @@ class MatlabExpressionWriter(PythonExpressionWriter):
         self._function_prefix = ''
         self._fcond = 'ifthenelse'
 
-    def set_condition_function(self, func=None):
+    def set_condition_function(self, func):
         """
-        Sets a function name to use for if statements
+        Sets a function name to output to handle :class:`myokit.If`.
+
+        The function must take arguments ``(condition, value_if_true,
+        value_if_false)`` and will be used to handle both :class:`myokit.If`
+        and :class:`myokit.Piecewise`.
+
+        By default, `ifthenelse` is used, which the user is expected to define
+        if ``If`` or ``Piecewise`` will be used. For example::
+
+            function y = ifthenelse(condition, value_if_true, value_if_false)
+                if (condition)
+                    y = value_if_true;
+                else
+                    y = value_if_false;
+                end
+            end
 
-        By setting func to None you can revert back to the default behavior
-         (the ternary operator). Any other value will be interpreted as the
-         name of a function taking arguments (condition, value_if_true,
-         value_if_false).
         """
+        if func is not None:
+            func = str(func).strip()
+        if func is None or func == '':
+            raise ValueError(
+                'The MatlabExpressionWriter needs a condition function to be'
+                ' set.')
         self._fcond = func
 
     #def _ex_name(self, e):
@@ -40,14 +59,17 @@ class MatlabExpressionWriter(PythonExpressionWriter):
 
     def _ex_quotient(self, e):
         # Round towards minus infinity
-        return 'floor(' + self._ex_infix(e, '/') + ')'
+        return self.ex(myokit.Floor(myokit.Divide(e[0], e[1])))
 
     def _ex_remainder(self, e):
         # Uses the round-towards-minus-infinity convention!
-        return 'mod(' + self.ex(e[0]) + ', ' + self.ex(e[1]) + ')'
+        return f'mod({self.ex(e[0])}, {self.ex(e[1])})'
 
     def _ex_power(self, e):
-        return self._ex_infix(e, '^')
+        # Same associativity as Myokit, not Python! So override
+        e1 = f'({self.ex(e[0])})' if e.bracket(e[0]) else f'{self.ex(e[0])}'
+        e2 = f'({self.ex(e[1])})' if e.bracket(e[1]) else f'{self.ex(e[1])}'
+        return f'{e1}^{e2}'
 
     #def _ex_sqrt(self, e):
     #    Ignore imaginary part
@@ -63,8 +85,9 @@ class MatlabExpressionWriter(PythonExpressionWriter):
     def _ex_log(self, e):
         if len(e) == 1:
             return self._ex_function(e, 'log')
-        else:
-            return '(log(' + self.ex(e[0]) + ') / log(' + self.ex(e[1]) + '))'
+        # Always add brackets: Parent was expecting a function so will never
+        # have added them.
+        return f'(log({self.ex(e[0])}) / log({self.ex(e[1])}))'
 
     #def _ex_log10(self, e):
     #def _ex_floor(self, e):
@@ -73,9 +96,6 @@ class MatlabExpressionWriter(PythonExpressionWriter):
     def _ex_abs(self, e):
         return self._ex_function(e, 'abs')
 
-    def _ex_not(self, e):
-        return '!(' + self.ex(e[0]) + ')'
-
     #def _ex_equal(self, e):
     #def _ex_not_equal(self, e):
     #def _ex_more(self, e):
@@ -84,26 +104,28 @@ class MatlabExpressionWriter(PythonExpressionWriter):
     #def _ex_less_equal(self, e):
 
     def _ex_and(self, e):
-        return self._ex_infix_condition(e, '&&')
+        return self._ex_infix_logical(e, '&&')
 
     def _ex_or(self, e):
-        return self._ex_infix_condition(e, '||')
+        return self._ex_infix_logical(e, '||')
+
+    def _ex_not(self, e):
+        return f'(!{self.ex(e[0])})'
 
     def _ex_if(self, e):
-        return '%s(%s, %s, %s)' % (
-            self._fcond, self.ex(e._i), self.ex(e._t), self.ex(e._e))
+        _if, _then, _else = self.ex(e._i), self.ex(e._t), self.ex(e._e)
+        return f'{self._fcond}({_if}, {_then}, {_else})'
 
     def _ex_piecewise(self, e):
+        # Render ifs; add extra bracket if not a condition (see _ex_if)
+        _ifs = [self.ex(x) for x in e._i]
+        _thens = [self.ex(x) for x in e._e]
+
         s = []
-        n = len(e._i)
-        for i in range(0, n):
-            s.append(self._fcond)
-            s.append('(')
-            s.append(self.ex(e._i[i]))
-            s.append(', ')
-            s.append(self.ex(e._e[i]))
-            s.append(', ')
-        s.append(self.ex(e._e[n]))
-        s.append(')' * n)
+        n = len(_ifs)
+        for _if, _then in zip(_ifs, _thens):
+            s.append(f'{self._fcond}({_if}, {_then}, ')
+        s.append(_thens[-1])
+        s.append(')' * len(_ifs))
         return ''.join(s)