myokit 1.38.0__py3-none-any.whl → 1.39.0__py3-none-any.whl

myokit/formats/mathml/_parser.py

@@ -6,6 +6,7 @@
 #
 import myokit
 
+from myokit.formats import is_integer_string, is_real_number_string
 from myokit.formats.xml import split
 
 
@@ -145,6 +146,13 @@ class MathMLParser:
     ``<rem>``
         Becomes a :class:`myokit.Remainder`.
 
+    Minimum and maximum
+
+    ``<max>`` and ``<min>``
+        Are converted to if-statements. Only binary comparisons are supported,
+        and the resulting ``if`` will evaluate its operands twice, which may be
+        inefficient if either operand is a complex expression.
+
     Trigonometry
 
     ``<sin>``, ``<cos>`` and ``<tan>``
@@ -415,6 +423,12 @@ class MathMLParser:
         elif name == 'leq':
             return myokit.LessEqual(*self._eat(element, iterator, 2))
 
+        # Min and max
+        elif name == 'min':
+            return self._parse_minmax(element, iterator, myokit.Less)
+        elif name == 'max':
+            return self._parse_minmax(element, iterator, myokit.More)
+
         # Trigonometry
         elif name == 'sin':
             return myokit.Sin(*self._eat(element, iterator))
@@ -655,6 +669,41 @@ class MathMLParser:
         else:
             return myokit.Log(op, base)
 
+    def _parse_minmax(self, element, iterator, operator):
+        """
+        Parses a ``min`` or ``max`` operation, replacing it with one or more
+        :class:`myokit.If` functions.
+
+        Caveats: Only binary min & max are supported, and if either operand is
+        a complex expression if will evaluated twice.
+
+        Arguments:
+
+        ``element``
+            The element that determined the operator type.
+        ``iterator``
+            An iterator pointing at the first element after ``element``.
+        ``operator``
+            Either :class:`myokit.Less` or :class:`myokit.More`, depending on
+            the desired operation.
+
+        """
+        # Get all operands
+        ops = [self._parse_atomic(x) for x in iterator]
+
+        # Check the number of operands
+        n = len(ops)
+        if n != 2:
+            raise MathMLError(
+                'Only binary min() and max() operations are supported.',
+                element)
+
+        # Return chain of ifs
+        e = ops[0]
+        for i in range(1, n):
+            e = myokit.If(operator(e, ops[i]), e, ops[i])
+        return e
+
     def _parse_nary(self, element, iterator, binary, unary=None):
         """
         Parses operands for unary, binary, or n-ary operators (for example
@@ -706,62 +755,51 @@ class MathMLParser:
 
         # Get value
         if kind == 'real':
-            # Float, specified as 123.123 (no exponent!)
-            # May be in a different base than 10
-            base = element.attrib.get('base', '10').strip()
-            try:
-                base = float(base)
-            except (TypeError, ValueError):
-                raise MathMLError(
-                    'Invalid base specified on <ci> element.', element)
+            # Float, specified as 123.123 (no exponent!). May be in a different
+            # base than 10.
+            base = element.attrib.get('base', '10')
+            if not is_integer_string(base, True):
+                raise MathMLError('Invalid base specified on <ci> element:'
+                                  f' {base}.', element)
+            base = int(base)
             if base != 10:
-                raise MathMLError(
-                    'Numbers in bases other than 10 are not supported.',
-                    element)
+                raise MathMLError('Real numbers in bases other than 10 are not'
+                                  ' supported.', element)
 
             # Get value
-            # Note: We are being tolerant here and allowing e-notation (which
-            # is not consistent with the spec!)
+            # Note: We are being tolerant here and allowing e-notation - which
+            # is not consistent with the spec.
             if element.text is None:
                 raise MathMLError('Empty <cn> element', element)
-            try:
-                value = float(element.text.strip())
-            except ValueError:
-                raise MathMLError(
-                    'Unable to convert contents of <cn> to a real number: "'
-                    + str(element.text) + '"', element)
+            if not is_real_number_string(element.text, True):
+                raise MathMLError('Unable to convert contents of <cn> to a'
+                                  f' real number: "{element.text}".', element)
+            value = float(element.text)
 
         elif kind == 'integer':
             # Integer in any given base
             base = element.attrib.get('base', '10').strip()
-            try:
-                base = int(base)
-            except ValueError:
-                raise MathMLError(
-                    'Unable to parse base of <cn> element: "' + base + '"',
-                    element)
+            if not is_integer_string(base, True):
+                raise MathMLError('Invalid base specified on <ci> element:'
+                                  f' {base}.', element)
+            base = int(base)
 
             # Get value
             if element.text is None:
                 raise MathMLError('Empty <cn> element', element)
-            try:
-                value = int(element.text.strip(), base)
-            except ValueError:
-                raise MathMLError(
-                    'Unable to convert contents of <cn> to an integer: "'
-                    + str(element.text) + '"', element)
+            if not is_integer_string(element.text, True):
+                raise MathMLError('Unable to convert contents of <cn> to an'
+                                  f' integer: "{element.text}".', element)
+            value = int(element.text, base)
 
         elif kind == 'double':
             # Floating point (positive, negative, exponents, etc)
-
             if element.text is None:
                 raise MathMLError('Empty <cn> element', element)
-            try:
-                value = float(element.text.strip())
-            except ValueError:
-                raise MathMLError(
-                    'Unable to convert contents of <cn> to a real number: "'
-                    + str(element.text) + '"', element)
+            if not is_real_number_string(element.text, True):
+                raise MathMLError('Unable to convert contents of <cn> to a'
+                                  f' real number: "{element.text}".', element)
+            value = float(element.text)
 
         elif kind == 'e-notation':
             # 1<sep />3 = 1e3
@@ -769,61 +807,62 @@ class MathMLParser:
             # Check contents
             parts = [x for x in element]
             if len(parts) != 1 or split(parts[0].tag)[1] != 'sep':
-                raise MathMLError(
-                    'Number in e-notation should have the format'
-                    ' number<sep />number.', element)
+                raise MathMLError('Number in e-notation should have the format'
+                                  ' number<sep />number.', element)
 
             # Get parts of number
             sig = element.text
             exp = parts[0].tail
-            if sig is None or not sig.strip():
+            if sig is None:
                 raise MathMLError(
                     'Unable to parse number in e-notation: missing part before'
                     ' the separator.', element)
-            if exp is None or not exp.strip():
+            if exp is None:
                 raise MathMLError(
                     'Unable to parse number in e-notation: missing part after'
                     ' the separator.', element)
 
-            # Get value
+            sig, exp = sig.strip(), exp.strip()
+            if not is_integer_string(exp):
+                raise MathMLError(
+                    'Unable to parse number in e-notation: part after the'
+                    ' separator should be an integer.', element)
+            # For sig, we can't allow e.g. 1e3, so different strategy
             try:
-                value = float(sig.strip() + 'e' + exp.strip())
+                value = float(f'{sig}e{exp}')
             except ValueError:
                 raise MathMLError(
-                    'Unable to parse number in e-notation "' + sig + 'e' + exp
-                    + '".', element)
+                    'Unable to parse number in e-notation: part before the'
+                    ' separator should be a basic real number.', element)
 
         elif kind == 'rational':
             # 1<sep />3 = 1 / 3
             # Check contents
             parts = [x for x in element]
             if len(parts) != 1 or split(parts[0].tag)[1] != 'sep':
-                raise MathMLError(
-                    'Rational number should have the format'
-                    ' number<sep />number.', element)
+                raise MathMLError('Rational number should have the format'
+                                  ' number<sep />number.', element)
 
             # Get parts of number
             numer = element.text
             denom = parts[0].tail
-            if numer is None or not numer.strip():
-                raise MathMLError(
-                    'Unable to parse rational number: missing part before the'
-                    ' separator.', element)
-            if denom is None or not denom.strip():
-                raise MathMLError(
-                    'Unable to parse rational number: missing part after the'
-                    ' separator.', element)
-
-            # Get value
-            try:
-                value = float(numer.strip()) / float(denom.strip())
-            except ValueError:
-                raise MathMLError(
-                    'Unable to parse rational number "' + numer + ' / ' + denom
-                    + '".', element)
+            if numer is None:
+                raise MathMLError('Unable to parse rational number: missing'
+                                  ' part before the separator.', element)
+            if denom is None:
+                raise MathMLError('Unable to parse rational number: missing'
+                                  ' part after the separator.', element)
+
+            if not is_integer_string(numer, True):
+                raise MathMLError('Unable to parse rational : part before the'
+                                  ' separator should be an integer.', element)
+            if not is_integer_string(denom, True):
+                raise MathMLError('Unable to parse rational : part after the'
+                                  ' separator should be an integer.', element)
+            value = int(numer) / int(denom)
 
         else:
-            raise MathMLError('Unsupported <cn> type: ' + kind, element)
+            raise MathMLError(f'Unsupported <cn> type: {kind}', element)
 
         # Create number and return
         return self._nfac(value, element)

myokit/gui/source.py

@@ -51,6 +51,14 @@ COLOR_BRACKET = QtGui.QColor(240, 100, 0)
 # Selected line is highlighted
 COLOR_SELECTED_LINE = QtGui.QColor(238, 238, 238)
 
+# Real number regex
+# Note 1: The first part is a "lookbehind", that stops it matching just after a
+# word character, so in "a1" it won't match, and in "a.1" it won't start
+# matching until the "1" because "." is not a word character.
+# Note 2: The remainder is the same as in myokit.float
+# Note 3: Deliberately unsigned
+LITERAL = rf'(?<!\w){myokit._RE_UNSIGNED_REAL}'
+
 
 def _adapt_for_dark_mode(palette):
     """
@@ -991,24 +999,24 @@ class ModelHighlighter(QtGui.QSyntaxHighlighter):
         self._rules = []
 
         # Numbers
-        pattern = R(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b')
-        self._rules.append((pattern, STYLE_LITERAL))
+        self._rules.append((R(LITERAL), STYLE_LITERAL))
         unit = r'\[([a-zA-Z0-9/^-]|\*)+\]'
         self._rules.append((R(unit), STYLE_INLINE_UNIT))
 
         # Keywords
+        # Note: \b is a "word boundary" match
         for keyword in self.KEYWORD_1:
-            self._rules.append((R(r'\b' + keyword + r'\b'), STYLE_KEYWORD_1))
+            self._rules.append((R(rf'\b{keyword}\b'), STYLE_KEYWORD_1))
         for keyword in self.KEYWORD_2:
-            self._rules.append((R(r'\b' + keyword + r'\b'), STYLE_KEYWORD_2))
+            self._rules.append((R(rf'\b{keyword}\b'), STYLE_KEYWORD_2))
 
         # Meta-data coloring
         self._rules_labels = [
-            R(r'(\s*)(bind)\s+(' + name + ')'),
-            R(r'(\s*)(label)\s+(' + name + ')'),
+            R(rf'(\s*)(bind)\s+({name})'),
+            R(rf'(\s*)(label)\s+({name})'),
         ]
-        self._rule_meta = R(r'^\s*(' + name + r':)(\s*)(.+)')
-        self._rule_var_unit = R(r'^(\s*)(in)(\s*)(' + unit + ')')
+        self._rule_meta = R(rf'^\s*({name}:)(\s*)(.+)')
+        self._rule_var_unit = R(rf'^(\s*)(in)(\s*)({unit})')
 
         # Comment
         self._comment = R(r'#')
@@ -1141,8 +1149,7 @@ class ProtocolHighlighter(QtGui.QSyntaxHighlighter):
         self._rules = []
 
         # Numbers
-        self._rules.append(
-            (R(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b'), STYLE_LITERAL))
+        self._rules.append((R(LITERAL), STYLE_LITERAL))
 
         # Keyword "next"
         self._rules.append((R(r'\bnext\b'), STYLE_KEYWORD_1))
@@ -1192,8 +1199,7 @@ class ScriptHighlighter(QtGui.QSyntaxHighlighter):
 
         # Literals: numbers, True, False, None
         # Override some keywords
-        self._rules.append((R(r'\b[+-]?[0-9]*\.?[0-9]+([eE][+-]?[0-9]+)?\b'),
-                            STYLE_LITERAL))
+        self._rules.append((R(LITERAL), STYLE_LITERAL))
         self._rules.append((R(r'\bTrue\b'), STYLE_LITERAL))
         self._rules.append((R(r'\bFalse\b'), STYLE_LITERAL))
         self._rules.append((R(r'\bNone\b'), STYLE_LITERAL))

myokit/lib/hh.py

@@ -123,13 +123,12 @@ class HHModel:
             try:
                 state = self._model.get(str(state), myokit.Variable)
             except KeyError:
-                raise HHModelError('Unknown state: <' + str(state) + '>.')
+                raise HHModelError(f'Unknown state: <{state}>.')
             if not state.is_state():
                 raise HHModelError(
-                    'Variable <' + state.qname() + '> is not a state.')
+                    f'Variable <{state.qname()}> is not a state.')
             if state in self._states:
-                raise HHModelError(
-                    'State <' + state.qname() + '> was added twice.')
+                raise HHModelError(f'State <{state.qname()}> was added twice.')
             self._states.append(state)
         del states
 
@@ -144,14 +143,11 @@ class HHModel:
             try:
                 parameter = self._model.get(parameter, myokit.Variable)
             except KeyError:
-                raise HHModelError(
-                    'Unknown parameter: <' + str(parameter) + '>.')
+                raise HHModelError(f'Unknown parameter: <{parameter}>.')
             if not parameter.is_literal():
-                raise HHModelError(
-                    'Unsuitable parameter: <' + str(parameter) + '>.')
+                raise HHModelError(f'Unsuitable parameter: <{parameter}>.')
             if parameter in unique:
-                raise HHModelError(
-                    'Parameter listed twice: <' + str(parameter) + '>.')
+                raise HHModelError(f'Parameter listed twice: <{parameter}>.')
             unique.add(parameter)
             self._parameters.append(parameter)
         del unique
@@ -217,7 +213,7 @@ class HHModel:
         for state in self._states:
             if not has_inf_tau_form(state, self._membrane_potential):
                 raise HHModelError(
-                    'State `' + state.qname() + '` must have "inf-tau form" or'
+                    f'State `{state.qname()}` must have "inf-tau form" or'
                     ' "alpha-beta form". See'
                     ' `myokit.lib.hh.has_inf_tau_form()` and'
                     ' `myokit.lib.hh.has_alpha_beta_form()`.'
@@ -294,13 +290,9 @@ class HHModel:
             inf = w.ex(myokit.Name(inf))
             tau = w.ex(myokit.Name(tau))
             k = str(k)
-            f.append(
-                '_y[' + k + '] = ' + state.uname() + ' = '
-                + inf + ' + (_y0[' + k + '] - ' + inf
-                + ') * numpy.exp(-_t / ' + tau + ')')
-            f.append(
-                '_y[' + k + '][_t == 0] = ' + state.uname() + '[_t == 0] = '
-                + '_y0[' + k + ']')
+            f.append(f'_y[{k}] = {state.uname()} ='
+                     f' {inf} + (_y0[{k}] - {inf}) * numpy.exp(-_t / {tau})')
+            f.append(f'_y[{k}][_t == 0] = {state.uname()}[_t == 0] = _y0[{k}]')
 
         # Add current calculation
         if self._current is not None:
@@ -313,7 +305,6 @@ class HHModel:
         for i in range(1, len(f)):
             f[i] = '    ' + f[i]
         f = '\n'.join(f)
-        #print(f)
         local = {}
         exec(f, {'numpy': np}, local)
         self._function = local['_f']
@@ -331,7 +322,7 @@ class HHModel:
             k = str(k)
             inf, tau = get_inf_and_tau(state, self._membrane_potential)
             inf = inf.rhs().clone(expand=True, retain=self._inputs)
-            g.append('_y[' + str(k) + '] = ' + w.ex(inf))
+            g.append(f'_y[{k}] = {w.ex(inf)}')
 
         # Create python function from g
         g.append('return _y')
@@ -431,8 +422,7 @@ class HHModel:
                 raise HHModelError(
                     'The given component has more than one variable that could'
                     ' be a current: '
-                    + ', '.join(['<' + x.qname() + '>' for x in currents])
-                    + '.')
+                    + ', '.join([f'<{x.qname()}>' for x in currents]) + '.')
             try:
                 current = currents[0]
             except IndexError:
@@ -494,9 +484,8 @@ class HHModel:
         if parameters is not None:
             if len(parameters) != len(self._parameters):
                 raise ValueError(
-                    'Illegal parameter vector size: '
-                    + str(len(self._parameters)) + ' required, '
-                    + str(len(parameters)) + ' provided.')
+                    f'Illegal parameter vector size: f{len(self._parameters)}'
+                    f' required, {len(parameters)} provided.')
             inputs[1:] = [float(x) for x in parameters]
         return inputs
 
@@ -764,8 +753,7 @@ class AnalyticalSimulation:
                     log[key] = np.concatenate((
                         log[key], np.zeros(log_times.shape)))
             except KeyError:
-                raise ValueError(
-                    'Invalid log: missing entry for <' + str(key) + '>.')
+                raise ValueError(f'Invalid log: missing entry for <{key}>.')
 
         # Run simulation
         if self._protocol is None:
@@ -855,8 +843,7 @@ class AnalyticalSimulation:
                 'Wrong size state vector, expecing (' + str(len(self._state))
                 + ') values.')
         if np.any(state < 0) or np.any(state > 1):
-            raise ValueError(
-                'All states must be in the range [0, 1].')
+            raise ValueError('All states must be in the range [0, 1].')
         self._default_state = state
 
     def set_membrane_potential(self, v):
@@ -873,9 +860,8 @@ class AnalyticalSimulation:
         Changes the parameter values used in this simulation.
         """
         if len(parameters) != len(self._parameters):
-            raise ValueError(
-                'Wrong size parameter vector, expecting ('
-                + str(len(self._parameters)) + ') values.')
+            raise ValueError('Wrong size parameter vector, expecting'
+                             f' ({len(self._parameters)}) values.')
         self._parameters = np.array(parameters, copy=True, dtype=float)
 
     def set_state(self, state):
@@ -884,12 +870,10 @@ class AnalyticalSimulation:
         """
         state = np.array(state, copy=True, dtype=float)
         if len(state) != len(self._state):
-            raise ValueError(
-                'Wrong size state vector, expecing (' + str(len(self._state))
-                + ') values.')
+            raise ValueError('Wrong size state vector, expecting'
+                             f' ({len(self._state)}) values.')
         if np.any(state < 0) or np.any(state > 1):
-            raise ValueError(
-                'All states must be in the range [0, 1].')
+            raise ValueError('All states must be in the range [0, 1].')
         self._state = state
 
     def solve(self, times):