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

myokit/formats/opencl/_ewriter.py

@@ -6,47 +6,60 @@
 #
 import myokit
 
-from myokit.formats.python import PythonExpressionWriter
+from myokit.formats.ansic import CBasedExpressionWriter
 
 
-class OpenCLExpressionWriter(PythonExpressionWriter):
+class OpenCLExpressionWriter(CBasedExpressionWriter):
     """
     This :class:`ExpressionWriter <myokit.formats.ExpressionWriter>` translates
     Myokit :class:`expressions <myokit.Expression>` to OpenCL syntax.
+
+    Arguments:
+
+    ``precision``
+        By default, numbers are shown as e.g. ``1.23f``, denoting single
+        precision literals. To use double precision instead, set ``precision``
+        to ``myokit.DOUBLE_PRECISION``.
+    ``native_math``
+        By default, the software implementations of functions like ``log`` and
+        ``exp`` are used. To use the native version instead, set
+        ``native_math`` to ``True``.
+
     """
     def __init__(self, precision=myokit.SINGLE_PRECISION, native_math=True):
         super().__init__()
-        self._function_prefix = ''
         self._sp = (precision == myokit.SINGLE_PRECISION)
         self._nm = bool(native_math)
 
     def _exc(self, e):
         """Returns ``ex(e)`` if ``e`` is a Condition, else ``ex(e != 0)``."""
+        # Can be removed after https://github.com/myokit/myokit/issues/1056
         if isinstance(e, myokit.Condition):
             return self.ex(e)
         return self.ex(myokit.NotEqual(e, myokit.Number(0)))
 
-    def _ex_infix_condition(self, e, op):
+    def _ex_infix_comparison(self, e, op):
         """Handles ex() for infix condition operators (==, !=, > etc.)."""
+        # Can be removed after https://github.com/myokit/myokit/issues/1056
         c1 = isinstance(e[0], myokit.Condition)
         c2 = isinstance(e[1], myokit.Condition)
         if (c1 and c2) or not (c1 or c2):
-            a = self.ex(e[0])
-            b = self.ex(e[1])
+            return f'({self.ex(e[0])} {op} {self.ex(e[1])})'
         else:
-            a = self._exc(e[0])
-            b = self._exc(e[1])
-        return '(' + a + ' ' + op + ' ' + b + ')'
+            return f'({self._exc(e[0])} {op} {self._exc(e[1])})'
 
     def _ex_infix_logical(self, e, op):
-        """Handles ex() for infix logical operators."""
-        return '(' + self._exc(e[0]) + ' ' + op + ' ' + self._exc(e[1]) + ')'
+        # Can be removed after https://github.com/myokit/myokit/issues/1056
+        return f'({self._exc(e[0])} {op} {self._exc(e[1])})'
 
     #def _ex_name(self, e):
     #def _ex_derivative(self, e):
+    #def _ex_initial_value(self, e):
+    #def _ex_partial_derivative(self, e):
 
     def _ex_number(self, e):
-        return myokit.float.str(e) + 'f' if self._sp else myokit.float.str(e)
+        x = super()._ex_number(e)
+        return x + 'f' if self._sp else x
 
     #def _ex_prefix_plus(self, e):
     #def _ex_prefix_minus(self, e):
@@ -54,34 +67,15 @@ class OpenCLExpressionWriter(PythonExpressionWriter):
     #def _ex_minus(self, e):
     #def _ex_multiply(self, e):
 
-    def _ex_divide(self, e):
-        # Native divide seemed to cause some issues
-        #if self._nm:
-        #    return 'native_divide(' + self.ex(e[0]) +', '+ self.ex(e[1]) + ')'
-        #else:
-        return self._ex_infix(e, '/')
-
-    def _ex_quotient(self, e):
-        # Note that this _must_ round towards minus infinity.
-        # See myokit.Quotient.
-        # Assuming it follows C and so we need a custom implementation.
-        return self.ex(myokit.Floor(myokit.Divide(e[0], e[1])))
-
-    def _ex_remainder(self, e):
-        # Note that this _must_ use the same round-to-neg-inf convention as
-        # myokit.Quotient.
-        # Assuming it follows C and so we need a custom implementation.
-        return self.ex(myokit.Minus(
-            e[0], myokit.Multiply(e[1], myokit.Quotient(e[0], e[1]))))
-
-    def _ex_power(self, e):
-        if e[1] == myokit.Number(2):
-            if e.bracket(e[0]):
-                return '((' + self.ex(e[0]) + ') * (' + self.ex(e[0]) + '))'
-            else:
-                return '(' + self.ex(e[0]) + ' * ' + self.ex(e[0]) + ')'
-        else:
-            return 'pow(' + self.ex(e[0]) + ', ' + self.ex(e[1]) + ')'
+    # Native divide seemed to cause some issues
+    #def _ex_divide(self, e):
+    #    if self._nm:
+    #        return 'native_divide(' + self.ex(e[0]) +', '+ self.ex(e[1]) + ')'
+    #    return self._ex_infix(e, '/')
+
+    #def _ex_quotient(self, e):
+    #def _ex_remainder(self, e):
+    #def _ex_power(self, e):
 
     def _ex_sqrt(self, e):
         f = 'native_sqrt' if self._nm else 'sqrt'
@@ -99,41 +93,29 @@ class OpenCLExpressionWriter(PythonExpressionWriter):
         f = 'native_tan' if self._nm else 'tan'
         return self._ex_function(e, f)
 
-    def _ex_asin(self, e):
-        return self._ex_function(e, 'asin')
-
-    def _ex_acos(self, e):
-        return self._ex_function(e, 'acos')
-
-    def _ex_atan(self, e):
-        return self._ex_function(e, 'atan')
+    #def _ex_asin(self, e):
+    #def _ex_acos(self, e):
+    #def _ex_atan(self, e):
 
     def _ex_exp(self, e):
         f = 'native_exp' if self._nm else 'exp'
         return self._ex_function(e, f)
 
     def _ex_log(self, e):
-        f = 'native_log' if self._nm else 'log'
+        log = 'native_log' if self._nm else 'log'
         if len(e) == 1:
-            return self._ex_function(e, f)
-        return '(' + f + '(' + self.ex(e[0]) + ') / ' + f + '(' \
-            + self.ex(e[1]) + '))'
+            return self._ex_function(e, log)
+        # 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):
         f = 'native_log10' if self._nm else 'log10'
         return self._ex_function(e, f)
 
-    def _ex_floor(self, e):
-        return self._ex_function(e, 'floor')
-
-    def _ex_ceil(self, e):
-        return self._ex_function(e, 'ceil')
-
-    def _ex_abs(self, e):
-        return self._ex_function(e, 'fabs')
-
-    def _ex_not(self, e):
-        return '!(' + self._exc(e[0]) + ')'
+    #def _ex_floor(self, e):
+    #def _ex_ceil(self, e):
+    #def _ex_abs(self, e):
 
     #def _ex_equal(self, e):
     #def _ex_not_equal(self, e):
@@ -142,26 +124,27 @@ class OpenCLExpressionWriter(PythonExpressionWriter):
     #def _ex_more_equal(self, e):
     #def _ex_less_equal(self, e):
 
-    def _ex_and(self, e):
-        return self._ex_infix_logical(e, '&&')
+    #def _ex_and(self, e):
+    #def _ex_or(self, e):
 
-    def _ex_or(self, e):
-        return self._ex_infix_logical(e, '||')
+    def _ex_not(self, e):
+        # Can be removed after https://github.com/myokit/myokit/issues/1056
+        return f'(!{self._exc(e[0])})'
 
     def _ex_if(self, e):
-        return '(%s ? %s : %s)' % (
-            self._exc(e._i), self.ex(e._t), self.ex(e._e))
+        # Can be removed after https://github.com/myokit/myokit/issues/1056
+        _if, _then, _else = self._exc(e._i), self.ex(e._t), self.ex(e._e)
+        return f'({_if} ? {_then} : {_else})'
 
     def _ex_piecewise(self, e):
+        # Can be removed after https://github.com/myokit/myokit/issues/1056
+        _ifs = [self._exc(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('(')
-            s.append(self._exc(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'({_if} ? {_then} : ')
+        s.append(_thens[-1])
+        s.append(')' * len(_ifs))
         return ''.join(s)
 

myokit/formats/python/_ewriter.py

@@ -31,31 +31,37 @@ class PythonExpressionWriter(myokit.formats.ExpressionWriter):
         """
         self._flhs = f
 
+    def _ex_prefix(self, e, op):
+        """ Handles ex() for prefix operators. """
+        # No simplifications should be made here for PrefixPlus, see
+        #   https://github.com/myokit/myokit/issues/1054
+        if e.bracket(e[0]):
+            return f'{op}({self.ex(e[0])})'
+        return f'{op}{self.ex(e[0])}'
+
     def _ex_infix(self, e, op):
-        """
-        Handles ex() for infix operators
-        """
+        """ Handles ex() for infix operators, except Power. """
         if e.bracket(e[0]):
-            out = '(' + self.ex(e[0]) + ') ' + op
+            out = f'({self.ex(e[0])}) {op}'
         else:
-            out = self.ex(e[0]) + ' ' + op
+            out = f'{self.ex(e[0])} {op}'
         if e.bracket(e[1]):
-            return out + ' (' + self.ex(e[1]) + ')'
+            return f'{out} ({self.ex(e[1])})'
         else:
-            return out + ' ' + self.ex(e[1])
+            return f'{out} {self.ex(e[1])}'
 
     def _ex_function(self, e, func):
-        """
-        Handles ex() for function operators
-        """
-        return self._function_prefix + func \
-            + '(' + ', '.join([self.ex(x) for x in e]) + ')'
+        """ Handles ex() for function operators with operands. """
+        args = ', '.join([self.ex(x) for x in e])
+        return f'{self._function_prefix}{func}({args})'
 
-    def _ex_infix_condition(self, e, op):
-        """
-        Handles ex() for infix condition operators
-        """
-        return '(' + self.ex(e[0]) + ' ' + op + ' ' + self.ex(e[1]) + ')'
+    def _ex_infix_comparison(self, e, op):
+        """ Handles ex() for infix comparisons (``==``, ``>=``, etc.). """
+        return f'({self.ex(e[0])} {op} {self.ex(e[1])})'
+
+    def _ex_infix_logical(self, e, op):
+        """ Handles ex() for ``and`` and ``or``. """
+        return f'({self.ex(e[0])} {op} {self.ex(e[1])})'
 
     def _ex_name(self, e):
         return self._flhs(e)
@@ -64,22 +70,21 @@ class PythonExpressionWriter(myokit.formats.ExpressionWriter):
         return self._flhs(e)
 
     def _ex_initial_value(self, e):
-        return self._flhs(e)
+        raise NotImplementedError(
+            'Initial values are not supported by this expression writer.')
 
     def _ex_partial_derivative(self, e):
-        return self._flhs(e)
+        raise NotImplementedError(
+            'Partial derivatives are not supported by this expression writer.')
 
     def _ex_number(self, e):
-        return myokit.float.str(e)
+        return myokit.float.str(e).lstrip()
 
     def _ex_prefix_plus(self, e):
-        return self.ex(e[0])
+        return self._ex_prefix(e, '+')
 
     def _ex_prefix_minus(self, e):
-        if e.bracket(e[0]):
-            return '(-(' + self.ex(e[0]) + '))'
-        else:
-            return '(-' + self.ex(e[0]) + ')'
+        return self._ex_prefix(e, '-')
 
     def _ex_plus(self, e):
         return self._ex_infix(e, '+')
@@ -100,7 +105,17 @@ class PythonExpressionWriter(myokit.formats.ExpressionWriter):
         return self._ex_infix(e, '%')
 
     def _ex_power(self, e):
-        return self._ex_infix(e, '**')
+        # Note: Python uses a right-to-left order of operations for power, so
+        # that a**b**c means a**(b**c). In Myokit, a^b^c means (a^b)^c, so we
+        # need to reverse this for powers only.
+        if e.bracket(e[0]) or isinstance(e[0], myokit.Power):
+            out = f'({self.ex(e[0])})'
+        else:
+            out = f'{self.ex(e[0])}'
+        if e.bracket(e[1]) and not isinstance(e[1], myokit.Power):
+            return f'{out}**({self.ex(e[1])})'
+        else:
+            return f'{out}**{self.ex(e[1])}'
 
     def _ex_sqrt(self, e):
         return self._ex_function(e, 'sqrt')
@@ -139,46 +154,44 @@ class PythonExpressionWriter(myokit.formats.ExpressionWriter):
         return self._ex_function(e, 'ceil')
 
     def _ex_abs(self, e):
-        return 'abs(' + self.ex(e[0]) + ')'
-
-    def _ex_not(self, e):
-        return 'not (' + self.ex(e[0]) + ')'
+        return f'abs({self.ex(e[0])})'
 
     def _ex_equal(self, e):
-        return self._ex_infix_condition(e, '==')
+        return self._ex_infix_comparison(e, '==')
 
     def _ex_not_equal(self, e):
-        return self._ex_infix_condition(e, '!=')
+        return self._ex_infix_comparison(e, '!=')
 
     def _ex_more(self, e):
-        return self._ex_infix_condition(e, '>')
+        return self._ex_infix_comparison(e, '>')
 
     def _ex_less(self, e):
-        return self._ex_infix_condition(e, '<')
+        return self._ex_infix_comparison(e, '<')
 
     def _ex_more_equal(self, e):
-        return self._ex_infix_condition(e, '>=')
+        return self._ex_infix_comparison(e, '>=')
 
     def _ex_less_equal(self, e):
-        return self._ex_infix_condition(e, '<=')
+        return self._ex_infix_comparison(e, '<=')
 
     def _ex_and(self, e):
-        return self._ex_infix_condition(e, 'and')
+        return self._ex_infix_logical(e, 'and')
 
     def _ex_or(self, e):
-        return self._ex_infix_condition(e, 'or')
+        return self._ex_infix_logical(e, 'or')
+
+    def _ex_not(self, e):
+        return f'(not {self.ex(e[0])})'
 
     def _ex_if(self, e):
-        return '(' + self.ex(e._t) + ' if ' + self.ex(e._i) + ' else ' \
-                   + self.ex(e._e) + ')'
+        return f'({self.ex(e._t)} if {self.ex(e._i)} else {self.ex(e._e)})'
 
     def _ex_piecewise(self, e):
         s = ''
         n = len(e) // 2
         for i in range(0, n):
-            s += '(' + self.ex(e._e[i]) + ' if ' + self.ex(e._i[i]) + ' else '
-        s += self.ex(e._e[n])
-        s += ')' * n
+            s += f'({self.ex(e._e[i])} if {self.ex(e._i[i])} else '
+        s += self.ex(e._e[n]) + ')' * n
         return s
 
 
@@ -216,25 +229,43 @@ class NumPyExpressionWriter(PythonExpressionWriter):
 
     def _ex_atan(self, e):
         return self._ex_function(e, 'arctan')
+
     #def _ex_exp(self, e):
-    #def _ex_log(self, e):
+
+    def _ex_log(self, e):
+        if len(e) == 1:
+            return self._ex_function(e, 'log')
+        # Always add brackets here: The parent element will have been expecting
+        # a function (which never needs brackets) and so won't have added any.
+        return f'(numpy.log({self.ex(e[0])}) / numpy.log({self.ex(e[1])}))'
+
     #def _ex_log10(self, e):
     #def _ex_floor(self, e):
     #def _ex_ceil(self, e):
-    #def _ex_abs(self, e):
-    #def _ex_not(self, e):
+
+    def _ex_abs(self, e):
+        # Can't use default abs here, must be numpy.abs
+        return self._ex_function(e, 'abs')
+
     #def _ex_equal(self, e):
     #def _ex_not_equal(self, e):
     #def _ex_more(self, e):
     #def _ex_less(self, e):
     #def _ex_more_equal(self, e):
     #def _ex_less_equal(self, e):
-    #def _ex_and(self, e):
-    #def _ex_or(self, e):
+
+    def _ex_and(self, e):
+        return self._ex_function(e, 'logical_and')
+
+    def _ex_or(self, e):
+        return self._ex_function(e, 'logical_or')
+
+    def _ex_not(self, e):
+        return self._ex_function(e, 'logical_not')
 
     def _ex_if(self, e):
-        return self._function_prefix + 'select([' + self.ex(e._i) + '], [' \
-            + self.ex(e._t) + '], ' + self.ex(e._e) + ')'
+        return (f'{self._function_prefix}select('
+                f'[{self.ex(e._i)}], [{self.ex(e._t)}], {self.ex(e._e)})')
 
     def _ex_piecewise(self, e):
         n = len(e._i)

myokit/formats/stan/_ewriter.py

@@ -20,20 +20,6 @@ class StanExpressionWriter(PythonExpressionWriter):
         super().__init__()
         self._function_prefix = ''
 
-        self._fcond = None
-        self.set_condition_function('ifthenelse')
-
-    def set_condition_function(self, func=None):
-        """
-        Sets a function name to use for if statements
-
-        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).
-        """
-        self._fcond = func
-
     #def _ex_name(self, e):
     #def _ex_derivative(self, e):
     #def _ex_number(self, e):
@@ -49,11 +35,22 @@ class StanExpressionWriter(PythonExpressionWriter):
         return self.ex(myokit.Floor(myokit.Divide(e[0], e[1])))
 
     def _ex_remainder(self, e):
-        # fmod uses correct convention
-        return self._ex_function(e, 'fmod')
+        # Extra brackets needed: Minus has lower precedence than division.
+        i = myokit.Minus(e[0], myokit.Multiply(
+            e[1], myokit.Floor(myokit.Divide(e[0], e[1]))))
+        return f'({self.ex(i)})'
 
     def _ex_power(self, e):
-        return self._ex_infix(e, '^')
+        # Like Python (and unlike Myokit), Stan uses a right-associative power
+        # operator.
+        if e.bracket(e[0]) or isinstance(e[0], myokit.Power):
+            out = f'({self.ex(e[0])})'
+        else:
+            out = f'{self.ex(e[0])}'
+        if e.bracket(e[1]) and not isinstance(e[1], myokit.Power):
+            return f'{out}^({self.ex(e[1])})'
+        else:
+            return f'{out}^{self.ex(e[1])}'
 
     #def _ex_sqrt(self, e):
     #def _ex_sin(self, e):
@@ -65,22 +62,16 @@ class StanExpressionWriter(PythonExpressionWriter):
     #def _ex_exp(self, e):
 
     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]) + '))'
+        if len(e) == 2:
+            return f'(log({self.ex(e[0])}) / log({self.ex(e[1])}))'
+        return f'log({self.ex(e[0])})'
 
     def _ex_log10(self, e):
-        return 'log10(' + self.ex(e[0]) + ')'
+        return f'log10({self.ex(e[0])})'
 
     #def _ex_floor(self, e):
     #def _ex_ceil(self, e):
-
-    def _ex_abs(self, e):
-        return self._ex_function(e, 'abs')
-
-    def _ex_not(self, e):
-        return '!(' + self.ex(e[0]) + ')'
+    #def _ex_abs(self, e):
 
     #def _ex_equal(self, e):
     #def _ex_not_equal(self, e):
@@ -90,21 +81,22 @@ class StanExpressionWriter(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 ('(' + self.ex(e._i) + ' ? ' + self.ex(e._t) + ' : ' +
-                self.ex(e._e) + ')')
+        return f'({self.ex(e._i)} ? {self.ex(e._t)} : {self.ex(e._e)})'
 
     def _ex_piecewise(self, e):
         s = []
-        n = len(e._i)
-        for i in range(0, n):
-            s.append('(%s ? %s : ' % (self.ex(e._i[i]), self.ex(e._e[i])))
-        s.append(self.ex(e._e[n]))
-        s.append(')' * n)
+        for _if, _then in zip(e._i, e._e):
+            s.append(f'({self.ex(_if)} ? {self.ex(_then)} : ')
+        s.append(self.ex(e._e[-1]))
+        s.append(')' * len(e._i))
         return ''.join(s)
 

myokit/gui/source.py

@@ -985,7 +985,7 @@ class ModelHighlighter(QtGui.QSyntaxHighlighter):
 
         # Headers
         name = r'[a-zA-Z]+[a-zA-Z0-9_]*'
-        self._rule_head = R(r'^\s*(\[{1,2}' + name + '\]{1,2})')
+        self._rule_head = R(r'^\s*(\[{1,2}' + name + r'\]{1,2})')
 
         # Simple rules
         self._rules = []

myokit/lib/hh.py

@@ -298,6 +298,9 @@ class HHModel:
                 '_y[' + k + '] = ' + state.uname() + ' = '
                 + inf + ' + (_y0[' + k + '] - ' + inf
                 + ') * numpy.exp(-_t / ' + tau + ')')
+            f.append(
+                '_y[' + k + '][_t == 0] = ' + state.uname() + '[_t == 0] = '
+                + '_y0[' + k + ']')
 
         # Add current calculation
         if self._current is not None:

myokit/lib/markov.py

@@ -975,6 +975,10 @@ class AnalyticalSimulation:
         """
         self._parameters[self._parameter_map[variable]] = float(value)
 
+        # Invalidate cache
+        self._cached_matrices = {}
+        self._cached_solution = {}
+
     def set_default_state(self, state):
         """
         Changes this simulation's default state.
@@ -1492,6 +1496,8 @@ class DiscreteSimulation:
         Updates a single parameter to a new value.
         """
         self._parameters[self._parameter_map[variable]] = float(value)
+        self._cached_rates = None
+        self._cached_matrix = None
 
     def set_default_state(self, state):
         """

myokit/tests/__init__.py

@@ -10,6 +10,7 @@
 #
 import os
 import tempfile
+import unittest
 import warnings
 
 import myokit
@@ -256,3 +257,72 @@ def test_case_pk_model(parameters, times):
     partials = np.vstack([damount_dinitial_amount, damount_delimination_rate])
 
     return amount, partials
+
+
+class ExpressionWriterTestCase(unittest.TestCase):
+    """ Abstract class for expression writer tests. """
+
+    _name = None
+    _target = None
+    _update_lhs_function = True
+
+    @classmethod
+    def setUpClass(cls):
+        # Create a model with some variables for testing
+        cls.model = m = myokit.Model()
+        cls.component = c = m.add_component('comp')
+        cls.a = myokit.Name(c.add_variable('a', rhs=1))
+        cls.b = myokit.Name(c.add_variable('b', rhs=2))
+        cls.c = myokit.Name(c.add_variable('c', rhs=3))
+        cls.d = myokit.Name(c.add_variable('d', rhs=4))
+        cls.e = myokit.Name(c.add_variable('e', rhs=5))
+        cls.f = myokit.Name(c.add_variable('f', rhs=6))
+        cls.g = myokit.Name(c.add_variable('g', rhs=7))
+        cls.t = c.add_variable('t', rhs=0, binding='time')
+
+        # Set unames
+        m.validate()
+
+        # Create writer
+        cls.w = cls._target()
+        if cls._update_lhs_function:
+            cls.w.set_lhs_function(cls.lhs)
+
+        # Easy access to properties
+        cls.ab = (cls.a, cls.b)
+        cls.abc = (cls.a, cls.b, cls.c)
+        cls.abcd = (cls.a, cls.b, cls.c, cls.d)
+        cls.efg = (cls.e, cls.f, cls.g)
+
+    @classmethod
+    def lhs(cls, ex):
+        """
+        Easier to read LHS function: ignores components.
+
+        All LHS types are supported here: Lack of support for e.g. partial
+        derivatives should be implemented in the expression writers themselves.
+        """
+        if isinstance(ex, myokit.Name):
+            return ex.var().name()
+        elif isinstance(ex, myokit.Derivative):
+            return f'dot({ex.var().name()})'
+        elif isinstance(ex, myokit.InitialValue):
+            return f'initial({ex.var().name()})'
+        elif isinstance(ex, myokit.PartialDerivative):
+            v1 = ex.dependent_expression()
+            v2 = ex.independent_expression()
+            return f'partial({v1.var().name()}, {v2.var().name()})'
+        raise ValueError(f'Untested LHS type {type(ex)}')
+
+    def test_fetching(self):
+        # Test fetching using ewriter method
+        w = myokit.formats.ewriter(self._name)
+        self.assertIsInstance(w, self._target)
+
+    def test_bad_argument(self):
+        # Test without a Myokit expression
+        self.assertRaisesRegex(
+            ValueError, 'Unknown expression type', self.w.ex, 7)
+
+    def eq(self, expression, expected_output):
+        self.assertEqual(self.w.ex(expression), expected_output)