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

myokit/formats/ansic/_ewriter.py

@@ -9,32 +9,38 @@ import myokit
 from myokit.formats.python import PythonExpressionWriter
 
 
-class AnsiCExpressionWriter(PythonExpressionWriter):
+class CBasedExpressionWriter(PythonExpressionWriter):
     """
-    This :class:`ExpressionWriter <myokit.formats.ExpressionWriter>` writes
-    equations for variables in a C-style syntax.
+    Base class for C-style expression writers.
     """
     def __init__(self):
         super().__init__()
         self._function_prefix = ''
-        self._fcond = None
 
-    def set_condition_function(self, func=None):
-        """
-        Sets a function name to use for if statements
+    def _ex_prefix(self, e, op):
+        # PrefixPlus and PrefixMinus. No simplifications should be made here
+        # for PrefixPlus, see https://github.com/myokit/myokit/issues/1054
+        x = self.ex(e[0])
+        return f'{op}({x})' if e.bracket(e[0]) or x[0] == op else f'{op}{x}'
 
-        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 C function taking arguments (condition, value_if_true,
-         value_if_false).
-        """
-        self._fcond = func
+    def _ex_infix_comparison(self, e, op):
+        # For equals etc
+        return f'({self.ex(e[0])} {op} {self.ex(e[1])})'
+
+    def _ex_infix_logical(self, e, op):
+        # For and and or
+        return f'({self.ex(e[0])} {op} {self.ex(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):
+
     #def _ex_prefix_plus(self, e):
     #def _ex_prefix_minus(self, e):
+
     #def _ex_plus(self, e):
     #def _ex_minus(self, e):
     #def _ex_multiply(self, e):
@@ -43,17 +49,20 @@ class AnsiCExpressionWriter(PythonExpressionWriter):
     def _ex_quotient(self, e):
         # Note that this _must_ round towards minus infinity!
         # See myokit.Quotient !
+        # No extra brackets needed: Function
         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! Implementation below is consistent with Python
-        # convention:
-        return self.ex(myokit.Minus(
-            e[0], myokit.Multiply(e[1], myokit.Quotient(e[0], e[1]))))
+        # convention.
+        # 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 'pow(' + self.ex(e[0]) + ', ' + self.ex(e[1]) + ')'
+        return f'pow({self.ex(e[0])}, {self.ex(e[1])})'
 
     #def _ex_sqrt(self, e):
     #def _ex_sin(self, e):
@@ -67,7 +76,9 @@ class AnsiCExpressionWriter(PythonExpressionWriter):
     def _ex_log(self, e):
         if len(e) == 1:
             return self._ex_function(e, 'log')
-        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):
@@ -76,9 +87,6 @@ class AnsiCExpressionWriter(PythonExpressionWriter):
     def _ex_abs(self, e):
         return self._ex_function(e, 'fabs')
 
-    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):
@@ -87,32 +95,143 @@ class AnsiCExpressionWriter(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):
+        # C conditions all have brackets, so don't add more
+        if isinstance(e[0], (myokit.Condition)):
+            return f'(!{self.ex(e[0])})'
+        # But do add more if the user's being silly
+        return f'(!({self.ex(e[0])}))'
 
     def _ex_if(self, e):
-        ite = (self.ex(e._i), self.ex(e._t), self.ex(e._e))
-        if self._fcond is None:
-            return '(%s ? %s : %s)' % ite
-        else:
-            return '%s(%s, %s, %s)' % ((self._fcond,) + ite)
+        _if, _then, _else = self.ex(e._i), self.ex(e._t), self.ex(e._e)
+        # If i is not a condtion (which always gets brackets from this writer)
+        # then add brackets
+        if not isinstance(e._i, myokit.Condition):
+            _if = f'({_if})'
+        return f'({_if} ? {_then} : {_else})'
+
+    def _ex_piecewise(self, e):
+        # Render ifs; add extra bracket if not a condition (see _ex_if)
+        _ifs = [self.ex(x) if isinstance(x, myokit.Condition)
+                else f'({self.ex(x)})' for x in e._i]
+        _thens = [self.ex(x) for x in e._e]
+
+        s = []
+        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)
+
+
+class AnsiCExpressionWriter(CBasedExpressionWriter):
+    """
+    This :class:`ExpressionWriter <myokit.formats.ExpressionWriter>` writes
+    equations for variables in a C-style syntax.
+    """
+    def __init__(self):
+        super().__init__()
+        self._fcond = None
+
+    def set_condition_function(self, func=None):
+        """
+        Sets a function name to use for :class:`myokit.If`; if not set the
+        ternary operatur will be used.
+
+        If given, the function arguments should be ``(condition, value_if_true,
+        value_if_false)``. To revert to using the ternary operator, call with
+        ``func=None``.
+        """
+        self._fcond = func
+
+    #def _ex_name(self, e):
+    #def _ex_derivative(self, e):
+
+    def _ex_initial_value(self, e):
+        # These are disabled by default, but enabled here to support CVODES
+        # sensitivity calculations.
+        return self._flhs(e)
+
+    def _ex_partial_derivative(self, e):
+        # These are disabled by default, but enabled here to support CVODES
+        # sensitivity calculations.
+        return self._flhs(e)
+
+    #def _ex_number(self, e):
+
+    #def _ex_prefix_plus(self, e):
+    #def _ex_prefix_minus(self, e):
+
+    #def _ex_plus(self, e):
+    #def _ex_minus(self, e):
+    #def _ex_multiply(self, e):
+    #def _ex_divide(self, e):
+
+    #def _ex_quotient(self, e):
+    #def _ex_remainder(self, e):
+    #def _ex_power(self, e):
+    #def _ex_sqrt(self, e):
+    #def _ex_sin(self, e):
+    #def _ex_cos(self, e):
+    #def _ex_tan(self, e):
+    #def _ex_asin(self, e):
+    #def _ex_acos(self, e):
+    #def _ex_atan(self, e):
+    #def _ex_exp(self, e):
+    #def _ex_log(self, e):
+    #def _ex_log10(self, e):
+    #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):
+    #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_not(self, e):
+
+    def _ex_if(self, e):
+        # Allow _fcond
+
+        _if, _then, _else = self.ex(e._i), self.ex(e._t), self.ex(e._e)
+        # If i is not a condtion (which always gets brackets from this writer)
+        # then add brackets
+        if not isinstance(e._i, myokit.Condition):
+            _if = f'({_if})'
+
+        # Use if-then-else function?
+        if self._fcond is not None:
+            return f'{self._fcond}({_if}, {_then}, {_else})'
+
+        # Default: use ternary operator
+        return f'({_if} ? {_then} : {_else})'
 
     def _ex_piecewise(self, e):
+        # Allow _fcond
+
+        # Render ifs; add extra bracket if not a condition (see _ex_if)
+        _ifs = [self.ex(x) if isinstance(x, myokit.Condition)
+                else f'({self.ex(x)})' for x in e._i]
+        _thens = [self.ex(x) for x in e._e]
+
         s = []
-        n = len(e._i)
-        if self._fcond is None:
-            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)
+        n = len(_ifs)
+        if self._fcond is not None:
+            for _if, _then in zip(_ifs, _thens):
+                s.append(f'{self._fcond}({_if}, {_then}, ')
         else:
-            for i in range(0, n):
-                s.append(
-                    '%s(%s, %s, ' % (
-                        self._fcond, 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(_ifs, _thens):
+                s.append(f'({_if} ? {_then} : ')
+        s.append(_thens[-1])
+        s.append(')' * len(_ifs))
         return ''.join(s)
 

myokit/formats/cpp/_ewriter.py

@@ -12,4 +12,15 @@ class CppExpressionWriter(AnsiCExpressionWriter):
     This :class:`ExpressionWriter <myokit.formats.ExpressionWriter>` translates
     myokit :class:`expressions <myokit.Expression>` to their C++ equivalent.
     """
-    pass
+    # Note: The set_condition_function is used by the jacobian calculator
+    # Once that has gone, this can base off the CBasedExpressionWriter without
+    # any modifications (so two methods below can then go).
+
+    def _ex_initial_value(self, e):
+        raise NotImplementedError(
+            'Initial values are not supported by this expression writer.')
+
+    def _ex_partial_derivative(self, e):
+        raise NotImplementedError(
+            'Partial derivatives are not supported by this expression writer.')
+

myokit/formats/cuda/_ewriter.py

@@ -6,24 +6,26 @@
 #
 import myokit
 
-from myokit.formats.python import PythonExpressionWriter
+from myokit.formats.ansic import CBasedExpressionWriter
 
 
-class CudaExpressionWriter(PythonExpressionWriter):
+class CudaExpressionWriter(CBasedExpressionWriter):
     """
     This :class:`ExpressionWriter <myokit.formats.ExpressionWriter>` translates
     Myokit :class:`expressions <myokit.Expression>` to their CUDA equivalents.
     """
     def __init__(self, precision=myokit.SINGLE_PRECISION):
         super().__init__()
-        self._function_prefix = ''
         self._sp = (precision == myokit.SINGLE_PRECISION)
 
     #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):
@@ -32,30 +34,12 @@ class CudaExpressionWriter(PythonExpressionWriter):
     #def _ex_multiply(self, e):
     #def _ex_divide(self, e):
 
-    def _ex_quotient(self, e):
-        # Note that this _must_ round towards minus infinity.
-        # See myokit.Quotient
-        # CUDA docs are unclear on convention, so 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.
-        # CUDA docs are unclear on convention, so 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_quotient(self, e):
+    #def _ex_remainder(self, e):
 
     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:
-            f = 'powf' if self._sp else 'pow'
-            return f + '(' + self.ex(e[0]) + ', ' + self.ex(e[1]) + ')'
+        pow = 'powf' if self._sp else 'pow'
+        return f'{pow}({self.ex(e[0])}, {self.ex(e[1])})'
 
     def _ex_sqrt(self, e):
         f = 'sqrtf' if self._sp else 'sqrt'
@@ -112,35 +96,15 @@ class CudaExpressionWriter(PythonExpressionWriter):
         f = 'fabsf' if self._sp else 'fabs'
         return self._ex_function(e, f)
 
-    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):
     #def _ex_less(self, e):
     #def _ex_more_equal(self, e):
     #def _ex_less_equal(self, e):
-
-    def _ex_and(self, e):
-        return self._ex_infix_condition(e, '&&')
-
-    def _ex_or(self, e):
-        return self._ex_infix_condition(e, '||')
-
-    def _ex_if(self, e):
-        return '(%s ? %s : %s)' % (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.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)
-        return ''.join(s)
+    #def _ex_and(self, e):
+    #def _ex_or(self, e):
+    #def _ex_not(self, e):
+    #def _ex_if(self, e):
+    #def _ex_piecewise(self, e):
 

myokit/formats/easyml/_ewriter.py

@@ -1,6 +1,9 @@
 #
 # EasyML expression writer
 #
+# Supported functions:
+#  https://opencarp.org/documentation/examples/01_ep_single_cell/05_easyml
+#
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
@@ -8,24 +11,22 @@ import warnings
 
 import myokit
 
-from myokit.formats.python import PythonExpressionWriter
+from myokit.formats.ansic import CBasedExpressionWriter
 
 
-class EasyMLExpressionWriter(PythonExpressionWriter):
+class EasyMLExpressionWriter(CBasedExpressionWriter):
     """
     This :class:`ExpressionWriter <myokit.formats.ExpressionWriter>` writes
     equations for variables in EasyML syntax.
+
+    EasyML has a C-like syntax, and uses C operator precedence.
     """
     def __init__(self):
         super().__init__()
-        self._function_prefix = ''
 
     #def _ex_name(self, e):
     #def _ex_derivative(self, e):
-
-    def _ex_number(self, e):
-        return myokit.float.str(e)
-
+    #def _ex_number(self, e):
     #def _ex_prefix_plus(self, e):
     #def _ex_prefix_minus(self, e):
     #def _ex_plus(self, e):
@@ -33,69 +34,52 @@ class EasyMLExpressionWriter(PythonExpressionWriter):
     def _ex_minus(self, e):
         if isinstance(e[0], myokit.Exp) and isinstance(e[1], myokit.Number):
             if e[1].eval() == 1:
-                return 'expm1(' + self.ex(e[0][0]) + ')'
+                return f'expm1({self.ex(e[0][0])})'
         if isinstance(e[1], myokit.Exp) and isinstance(e[0], myokit.Number):
             if e[0].eval() == 1:
-                return '-expm1(' + self.ex(e[1][0]) + ')'
+                return f'-expm1({self.ex(e[1][0])})'
         return super()._ex_minus(e)
 
     #def _ex_multiply(self, e):
     #def _ex_divide(self, e):
-
-    def _ex_quotient(self, e):
-        return self.ex(myokit.Floor(myokit.Divide(e[0], e[1])))
-
-    def _ex_remainder(self, e):
-        return self.ex(myokit.Minus(
-            e[0], myokit.Multiply(e[1], myokit.Quotient(e[0], e[1]))))
-
-    def _ex_power(self, e):
-        return 'pow(' + self.ex(e[0]) + ', ' + self.ex(e[1]) + ')'
-
+    #def _ex_quotient(self, e):
+    #def _ex_remainder(self, e):
+    #def _ex_power(self, e):
     #def _ex_sqrt(self, e):
 
     def _ex_sin(self, e):
-        warnings.warn('Potentially unsupported function: sin()')
+        warnings.warn('Unsupported function: sin()')
         return super()._ex_sin(e)
 
     #def _ex_cos(self, e):
 
     def _ex_tan(self, e):
-        warnings.warn('Potentially unsupported function: tan()')
+        warnings.warn('Unsupported function: tan()')
         return super()._ex_tan(e)
 
     def _ex_asin(self, e):
-        warnings.warn('Potentially unsupported function: asin()')
+        warnings.warn('Unsupported function: asin()')
         return super()._ex_asin(e)
 
     #def _ex_acos(self, e):
 
     def _ex_atan(self, e):
-        warnings.warn('Potentially unsupported function: atan()')
+        warnings.warn('Unsupported function: atan()')
         return super()._ex_atan(e)
 
     #def _ex_exp(self, e):
-
-    def _ex_log(self, e):
-        if len(e) == 1:
-            return self._ex_function(e, 'log')
-        return '(log(' + self.ex(e[0]) + ') / log(' + self.ex(e[1]) + '))'
-
+    #def _ex_log(self, e):
     #def _ex_log10(self, e):
 
     def _ex_floor(self, e):
-        warnings.warn('Potentially unsupported function: floor()')
+        warnings.warn('Unsupported function: floor()')
         return super()._ex_floor(e)
 
     def _ex_ceil(self, e):
-        warnings.warn('Potentially unsupported function: ceil()')
+        warnings.warn('Unsupported function: ceil()')
         return super()._ex_ceil(e)
 
-    def _ex_abs(self, e):
-        return self._ex_function(e, 'fabs')
-
-    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):
@@ -104,22 +88,10 @@ class EasyMLExpressionWriter(PythonExpressionWriter):
     #def _ex_more_equal(self, e):
     #def _ex_less_equal(self, e):
 
-    def _ex_and(self, e):
-        return self._ex_infix_condition(e, 'and')
-
-    def _ex_or(self, e):
-        return self._ex_infix_condition(e, 'or')
-
-    def _ex_if(self, e):
-        ite = (self.ex(e._i), self.ex(e._t), self.ex(e._e))
-        return '(%s ? %s : %s)' % ite
+    #def _ex_not(self, e):
+    #def _ex_and(self, e):
+    #def _ex_or(self, 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)
-        return ''.join(s)
+    #def _ex_if(self, e):
+    #def _ex_piecewise(self, e):
 

myokit/formats/heka/_patchmaster.py

@@ -1359,8 +1359,17 @@ class Trace(TreeNode):
 
     def r_seal(self):
         """
-        Returns the seal resistance (MOhm) determined from the test pulse
+        Returns the "seal resistance" (MOhm) determined in the waiting time
         before the trace was acquired.
+
+        This is equal to the value "R-memb" on the display. If a test pulse is
+        being used, it is calculated as dV/dI where dV and dI are the
+        differences in (command) voltage and current before and during the
+        pulse. If no test pulse is used it is simply the ratio between the V
+        and I measurements.
+
+        This is the same measurement as :meth:`r_pipette`, but logged
+        automatically before each trace.
         """
         return self._r_seal * 1e-6
 
@@ -1384,8 +1393,11 @@ class Trace(TreeNode):
         Returns the pipette resistance (MOhm) determined from the test pulse
         before breaking the seal.
 
-        This was manually logged when the "R-memb to R-pip" button was pressed
-        before acquiring the data.
+        This is equal to the value "R-memb" on the display, but logged when a
+        "R-memb to R-pip" button was pressed (or called programmatically). It
+        uses the same measurement as  :meth:`r_seal`, but logged at a different
+        time. The intended use is to store the resistance of the pipette tip
+        before touching a cell.
         """
         return self._r_pipette * 1e-6