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

myokit/tests/test_formats_mathml_content.py

@@ -357,27 +357,10 @@ class ContentMathMLParserTest(unittest.TestCase):
         )
 
     def test_functions(self):
-        # Tests parsing basic functions
-
-        # Power
-        a = myokit.Name('a')
-        b = myokit.Number(1)
-        c = myokit.Number(2)
-        e = myokit.Power(a, b)
-        x = '<apply><power/><ci>a</ci><cn>1.0</cn></apply>'
-        self.assertEqual(self.p(x), e)
-        e = myokit.Power(myokit.Power(a, b), c)
-        x = ('<apply><power/><apply><power/><ci>a</ci><cn>1.0</cn></apply>'
-             '<cn>2.0</cn></apply>')
-        self.assertEqual(self.p(x), e)
-        e = myokit.Power(a, myokit.Power(b, c))
-        x = ('<apply><power/><ci>a</ci><apply><power/><cn>1.0</cn><cn>2.0</cn>'
-             '</apply></apply>')
-        self.assertEqual(self.p(x), e)
-
-        #TODO: Degree etc.
+        # Tests parsing simple functions
 
         # Exp
+        a = myokit.Name('a')
         e = myokit.Exp(a)
         x = '<apply><exp/><ci>a</ci></apply>'
         self.assertEqual(self.p(x), e)
@@ -393,10 +376,19 @@ class ContentMathMLParserTest(unittest.TestCase):
             mathml.MathMLError, r'Expecting 1 operand\(s\)', self.p, x)
 
         # Floor
+        b = myokit.Number(1)
         e = myokit.Floor(b)
         x = '<apply><floor/><cn>1.0</cn></apply>'
         self.assertEqual(self.p(x), e)
 
+        # Test number of arguments to unary operator
+        x = '<apply><floor/></apply>'
+        self.assertRaisesRegex(
+            mathml.MathMLError, r'Expecting 1 operand\(s\), got 0', self.p, x)
+        x = '<apply><floor/><cn>1.0</cn><cn>2.0</cn></apply>'
+        self.assertRaisesRegex(
+            mathml.MathMLError, r'Expecting 1 operand\(s\), got 2', self.p, x)
+
         # Ceil
         e = myokit.Ceil(b)
         x = '<apply><ceiling/><cn>1.0</cn></apply>'
@@ -466,6 +458,50 @@ class ContentMathMLParserTest(unittest.TestCase):
         self.assertRaisesRegex(
             mathml.MathMLError, 'Expecting a single', self.p, x)
 
+    def test_functions_minmax(self):
+        # Tests parsing min and max
+
+        a = myokit.Name('a')
+        b = myokit.Number(1)
+        x = '<apply><min/><ci>a</ci><cn>1.0</cn></apply>'
+        e = myokit.If(myokit.Less(a, b), a, b)
+        self.assertEqual(self.p(x), e)
+
+        c = myokit.Number(7)
+        x = '<apply><max/><cn>7.0</cn><ci>a</ci></apply>'
+        e = myokit.If(myokit.More(c, a), c, a)
+        self.assertEqual(self.p(x), e)
+
+        x = f'<apply><min/><ci>a</ci>{x}</apply>'
+        e = myokit.If(myokit.Less(a, e), a, e)
+        self.assertEqual(self.p(x), e)
+
+        # Unsupported number of operands
+        x = '<apply><min/><ci>a</ci></apply>'
+        self.assertRaisesRegex(mathml.MathMLError, 'Only binary', self.p, x)
+        x = '<apply><min/><ci>a</ci><ci>b</ci><ci>c</ci></apply>'
+        self.assertRaisesRegex(mathml.MathMLError, 'Only binary', self.p, x)
+
+    def test_functions_power(self):
+        # Tests parsing powers
+
+        a = myokit.Name('a')
+        b = myokit.Number(1)
+        c = myokit.Number(2)
+        e = myokit.Power(a, b)
+        x = '<apply><power/><ci>a</ci><cn>1.0</cn></apply>'
+        self.assertEqual(self.p(x), e)
+
+        e = myokit.Power(myokit.Power(a, b), c)
+        x = ('<apply><power/><apply><power/><ci>a</ci><cn>1.0</cn></apply>'
+             '<cn>2.0</cn></apply>')
+        self.assertEqual(self.p(x), e)
+
+        e = myokit.Power(a, myokit.Power(b, c))
+        x = ('<apply><power/><ci>a</ci><apply><power/><cn>1.0</cn><cn>2.0</cn>'
+             '</apply></apply>')
+        self.assertEqual(self.p(x), e)
+
     def test_functions_root(self):
         # Tests parsing roots
 
@@ -618,19 +654,28 @@ class ContentMathMLParserTest(unittest.TestCase):
         # Real
         x = self.p('<cn>4</cn>')
         self.assertEqual(x, myokit.Number(4))
-        x = self.p('<cn>   4  \n </cn>')
+        x = self.p('<cn>   4.0  \n </cn>')
         self.assertEqual(x, myokit.Number(4))
         x = self.p('<cn type="real">4</cn>')
         self.assertEqual(x, myokit.Number(4))
         self.assertRaisesRegex(
             mathml.MathMLError, 'Unable to convert contents of <cn>',
             self.p, '<cn>barry</cn>')
+        self.assertRaisesRegex(
+            mathml.MathMLError, 'Unable to convert contents of <cn>',
+            self.p, '<cn>nan</cn>')
+        self.assertRaisesRegex(
+            mathml.MathMLError, 'Unable to convert contents of <cn>',
+            self.p, '<cn>-Infinity</cn>')
+        self.assertRaisesRegex(
+            mathml.MathMLError, 'Unable to convert contents of <cn>',
+            self.p, '<cn>\n+inf</cn>')
 
         # Real with base
-        x = self.p('<cn type="real" base="10">4</cn>')
-        self.assertEqual(x, myokit.Number(4))
-        x = self.p('<cn type="real" base="  10  ">4</cn>')
-        self.assertEqual(x, myokit.Number(4))
+        self.assertEqual(
+            myokit.Number(4), self.p('<cn type="real" base="10">4</cn>'))
+        self.assertEqual(
+            myokit.Number(-3), self.p('<cn type="real" base=" 10 ">-3.0</cn>'))
         self.assertRaisesRegex(
             mathml.MathMLError, 'bases other than 10',
             self.p, '<cn type="real" base="9">4</cn>')
@@ -653,43 +698,58 @@ class ContentMathMLParserTest(unittest.TestCase):
         x = self.p('<cn type="integer" base="  2  ">100</cn>')
         self.assertEqual(x, myokit.Number(4))
         self.assertRaisesRegex(
-            mathml.MathMLError, 'Unable to parse base',
+            mathml.MathMLError, 'Invalid base specified',
             self.p, '<cn type="integer" base="barry">7</cn>')
 
         # Double
-        x = self.p('<cn type="double">4</cn>')
-        self.assertEqual(x, myokit.Number(4))
-        x = self.p('<cn type="double">\t4\n</cn>')
-        self.assertEqual(x, myokit.Number(4))
+        self.assertEqual(
+            myokit.Number(-3), self.p('<cn type="double">-3</cn>'))
+        self.assertEqual(
+            myokit.Number(4), self.p('<cn type="double">\t4\n</cn>'))
         self.assertRaisesRegex(
             mathml.MathMLError, 'Unable to convert contents of <cn>',
             self.p, '<cn type="double">larry</cn>')
+        self.assertRaisesRegex(
+            mathml.MathMLError, 'Unable to convert contents of <cn>',
+            self.p, '<cn type="double">nan</cn>')
 
         # E-notation
         x = self.p('<cn type="e-notation">40<sep/>-1</cn>')
         self.assertEqual(x, myokit.Number(4))
         x = self.p('<cn type="e-notation">\n40<sep/>-1</cn>')
         self.assertEqual(x, myokit.Number(4))
-        x = self.p('<cn type="e-notation">40<sep/>\t-1</cn>')
-        self.assertEqual(x, myokit.Number(4))
+        x = self.p('<cn type="e-notation"> -40.3<sep/>\t-12</cn>')
+        self.assertEqual(x, myokit.Number(-40.3e-12))
         self.assertRaisesRegex(
             mathml.MathMLError, 'e-notation should have the format',
             self.p, '<cn type="e-notation">12</cn>')
         self.assertRaisesRegex(
-            mathml.MathMLError, 'missing part before the separator',
+            mathml.MathMLError, 'before the separator should be a basic real',
             self.p, '<cn type="e-notation"> <sep/>2</cn>')
         self.assertRaisesRegex(
             mathml.MathMLError, 'missing part before the separator',
             self.p, '<cn type="e-notation"><sep/>2</cn>')
         self.assertRaisesRegex(
-            mathml.MathMLError, 'missing part after the separator',
+            mathml.MathMLError, 'after the separator should be an integer',
             self.p, '<cn type="e-notation">2<sep/> </cn>')
         self.assertRaisesRegex(
             mathml.MathMLError, 'missing part after the separator',
             self.p, '<cn type="e-notation">2<sep/></cn>')
         self.assertRaisesRegex(
-            mathml.MathMLError, 'Unable to parse number in e-notation',
+            mathml.MathMLError, 'before the separator should be a basic real',
+            self.p, '<cn type="e-notation">1e3<sep/>1</cn>')
+        self.assertRaisesRegex(
+            mathml.MathMLError, 'after the separator should be an integer',
+            self.p, '<cn type="e-notation">1<sep/>1e3</cn>')
+        self.assertRaisesRegex(
+            mathml.MathMLError, 'before the separator should be a basic real',
             self.p, '<cn type="e-notation">larry<sep/>2</cn>')
+        self.assertRaisesRegex(
+            mathml.MathMLError, 'should be a basic real number',
+            self.p, '<cn type="e-notation">nan<sep/>2</cn>')
+        self.assertRaisesRegex(
+            mathml.MathMLError, 'after the separator should be an integer',
+            self.p, '<cn type="e-notation">1<sep/>inf</cn>')
 
         # Rational
         x = self.p('<cn type="rational">16<sep/>4</cn>')
@@ -702,7 +762,7 @@ class ContentMathMLParserTest(unittest.TestCase):
             mathml.MathMLError, 'Rational number should have the format',
             self.p, '<cn type="rational">12</cn>')
         self.assertRaisesRegex(
-            mathml.MathMLError, 'missing part before the separator',
+            mathml.MathMLError, 'before the separator should be an integer',
             self.p, '<cn type="rational"> <sep/>2</cn>')
         self.assertRaisesRegex(
             mathml.MathMLError, 'missing part before the separator',
@@ -711,10 +771,10 @@ class ContentMathMLParserTest(unittest.TestCase):
             mathml.MathMLError, 'missing part after the separator',
             self.p, '<cn type="rational">1<sep/></cn>')
         self.assertRaisesRegex(
-            mathml.MathMLError, 'missing part after the separator',
+            mathml.MathMLError, 'after the separator should be an integer',
             self.p, '<cn type="rational">1<sep/> </cn>')
         self.assertRaisesRegex(
-            mathml.MathMLError, 'Unable to parse rational number',
+            mathml.MathMLError, 'before the separator should be an integer',
             self.p, '<cn type="rational">larry<sep/>2</cn>')
 
         # Unknown type

myokit/tests/test_formats_python.py

@@ -302,7 +302,7 @@ class NumPyExpressionWriterTest(myokit.tests.ExpressionWriterTestCase):
         if arguments:
             arguments = [numpy.array(arg) for arg in arguments]
             values = function(*arguments)
-            self.assertEqual(list(values), list(expected))
+            self.assertLess(numpy.max(numpy.abs(values - expected)), 1e-12)
         else:
             value = function()
             self.assertEqual(value, expected)

myokit/tests/test_model_building.py

@@ -400,6 +400,7 @@ class ModelBuildTest(unittest.TestCase):
         # Keywords
         self.assertRaises(myokit.InvalidNameError, m.add_component, 'and')
         self.assertRaises(myokit.InvalidNameError, m.add_component, 'bind')
+        self.assertRaises(myokit.InvalidNameError, m.add_component, 'infinity')
         # Test adding variable to component
         c1 = m.add_component('c1')
         # Duplicate
@@ -414,6 +415,7 @@ class ModelBuildTest(unittest.TestCase):
         # Keywords
         self.assertRaises(myokit.InvalidNameError, c0.add_variable, 'or')
         self.assertRaises(myokit.InvalidNameError, c0.add_variable, 'label')
+        self.assertRaises(myokit.InvalidNameError, c0.add_variable, 'nan')
 
         # Test adding variable to variable
         v1 = c0.add_variable('c0')

myokit/tests/test_parsing.py

@@ -6,6 +6,7 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
+import math
 import os
 import unittest
 
@@ -36,6 +37,12 @@ class TokenizerTest(unittest.TestCase):
         s = Tokenizer('.30')
         self.assertEqual(next(s), (p.FLOAT, '.30', 1, 0))
 
+        # Infinity and nan count as numbers
+        s = Tokenizer('infinity')
+        self.assertEqual(next(s), (p.INF, 'infinity', 1, 0))
+        s = Tokenizer('nan')
+        self.assertEqual(next(s), (p.NAN, 'nan', 1, 0))
+
         # Finished? Then should get a StopIteration
         self.assertEqual(s.peek()[0], p.EOL)
         self.assertEqual(next(s)[0], p.EOL)
@@ -716,6 +723,31 @@ class PhasedParseTest(unittest.TestCase):
         self.assertRaisesRegex(
             myokit.ParseError, 'not be a condition', p, code)
 
+    def test_parse_nan_inf(self):
+        # Nan and inf are recognised as numbers, and can have units
+        from myokit._parsing import parse_model as p
+
+        s = ('[[model]]',
+             '[x]',
+             't = 0 bind time',
+             'a = infinity + nan [mV]',
+             'b = -infinity')
+        e = p(s).get('x.a').rhs()
+        self.assertIsInstance(e, myokit.Plus)
+        self.assertIsInstance(e[0], myokit.Number)
+        self.assertGreater(e[0].value(), 0)
+        self.assertTrue(math.isinf(e[0].value()))
+        self.assertEqual(e[0].unit(), None)
+        self.assertTrue(math.isnan(e[1].value()))
+        self.assertEqual(e[1].unit(), myokit.units.mV)
+        e = p(s).get('x.b').rhs()
+        self.assertIsInstance(e, myokit.PrefixMinus)
+        self.assertLess(e.eval(), 0)
+        self.assertTrue(math.isinf(e.eval()))
+        self.assertIsInstance(e[0], myokit.Number)
+        self.assertGreater(e[0].value(), 0)
+        self.assertTrue(math.isinf(e[0].value()))
+
     def test_parse_unit(self):
         # Test :meth:`parse_unit` and :meth:`parse_unit_string`.
         from myokit._parsing import parse_unit_string as p

myokit/tests/test_simulation_cvodes.py

@@ -522,16 +522,17 @@ class SimulationTest(unittest.TestCase):
             ValueError, 'no `apd_variable` specified',
             self.sim.run, 1, apd_threshold=12)
 
-    def test_crash_state_and_inputs(self):
-        # Tests Simulation.crash_state
+    def test_crash_state_inputs_log(self):
+        # Tests Simulation.crash_state, crash_inputs, and crash_log
 
         m = self.model.clone()
         istim = m.get('membrane.i_stim')
         istim.set_rhs('engine.pace / stim_amplitude')
-        '''
+
         s = myokit.Simulation(m, self.protocol)
         self.assertIsNone(s.crash_state())
         self.assertIsNone(s.crash_inputs())
+        self.assertIsNone(s.crash_log())
         s.run(1)
         self.assertIsNone(s.crash_state())
         s.set_constant('membrane.i_stim.stim_amplitude', 0)
@@ -545,7 +546,8 @@ class SimulationTest(unittest.TestCase):
         self.assertEqual(s.crash_inputs()['pace'], 0)
         self.assertGreaterEqual(s.crash_inputs()['realtime'], 0)
         self.assertGreater(s.crash_inputs()['evaluations'], 0)
-        '''
+        self.assertIsInstance(s.crash_log(), myokit.DataLog)
+        self.assertGreater(s.crash_log().length(), 0)
 
         # Test crash at later time
         istim.set_rhs('if(engine.time == 5, 1 / (5 - engine.time), 0)')
@@ -561,6 +563,8 @@ class SimulationTest(unittest.TestCase):
         self.assertEqual(s.crash_inputs()['time'], 5)
         self.assertEqual(s.crash_inputs()['pace'], 1)
         self.assertGreater(s.crash_inputs()['realtime'], 0)
+        self.assertIsInstance(s.crash_log(), myokit.DataLog)
+        self.assertGreater(s.crash_log().length(), 0)
 
         # Above should both crash via cvode flag set. Next should be halted by
         # C code for too many zero steps
@@ -572,6 +576,8 @@ class SimulationTest(unittest.TestCase):
         self.assertAlmostEqual(s.crash_inputs()['time'], 5)
         self.assertEqual(s.crash_inputs()['pace'], 1)
         self.assertGreater(s.crash_inputs()['realtime'], 0)
+        self.assertIsInstance(s.crash_log(), myokit.DataLog)
+        self.assertGreater(s.crash_log().length(), 0)
 
         # Test deprecated alias of crash_state
         x = s.crash_state()

myokit/tests/test_variable.py

@@ -768,14 +768,18 @@ class VariableTest(unittest.TestCase):
         v.set_initial_value(myokit.Number(12, myokit.units.g))
         self.assertEqual(v.initial_value(), myokit.Number(12, myokit.units.g))
 
-        # Test setting expressions
-        v.set_initial_value('1 + 11')
-        #self.assertEqual(v.initial_value(),
-        #                 myokit.Plus(myokit.Number(1), myokit.Number(11)))
+        # Test setting expressions and strings
+        e = myokit.Plus(myokit.Number(1), myokit.Number(11))
+        v.set_initial_value(e)
+        self.assertEqual(v.initial_value(), e)
         v.set_initial_value('1 + c.w')
         self.assertEqual(v.initial_value(),
                          myokit.Plus(myokit.Number(1), myokit.Name(w)))
 
+        # Test setting using variables
+        v.set_initial_value(w)
+        self.assertEqual(v.initial_value(), myokit.Name(w))
+
         # Strings must use global context
         self.assertRaisesRegex(myokit.ParseError, 'No component specified for',
                                v.set_initial_value, '1 / w')
@@ -802,9 +806,8 @@ class VariableTest(unittest.TestCase):
         x = v.add_variable('x')
         x.set_rhs(1)
         v.set_initial_value(x.lhs())
-        self.assertRaises(
-            myokit.IllegalReferenceInInitialValueError, m.validate)
-        v.set_initial_value(x)
+        self.assertRaisesRegex(
+            myokit.IllegalReferenceInInitialValueError, 'is nest', m.validate)
 
         # InitialValue and PartialDerivative can not be used
         v.set_initial_value(myokit.PartialDerivative(v.lhs(), x.lhs()))

{myokit-1.37.5.dist-info → myokit-1.39.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: myokit
-Version: 1.37.5
+Version: 1.39.0
 Summary: A modeling and simulation tool for cardiac cellular electrophysiology
 Home-page: http://myokit.org
 Author: Michael Clerx
@@ -28,22 +28,35 @@ Requires-Dist: lxml
 Requires-Dist: matplotlib>=2.2
 Requires-Dist: numpy
 Requires-Dist: setuptools
+Provides-Extra: docs
+Requires-Dist: sphinx>=1.7.4; extra == "docs"
 Provides-Extra: dev
 Requires-Dist: coverage; extra == "dev"
 Requires-Dist: flake8>=3; extra == "dev"
-Provides-Extra: docs
-Requires-Dist: sphinx>=1.7.4; extra == "docs"
-Provides-Extra: gui
-Requires-Dist: pyqt6; extra == "gui"
-Requires-Dist: sip; extra == "gui"
 Provides-Extra: optional
 Requires-Dist: scipy; extra == "optional"
 Requires-Dist: sympy; extra == "optional"
+Provides-Extra: gui
+Requires-Dist: pyqt6; extra == "gui"
+Requires-Dist: sip; extra == "gui"
 Provides-Extra: pyqt
 Requires-Dist: pyqt6; extra == "pyqt"
 Requires-Dist: sip; extra == "pyqt"
 Provides-Extra: pyside
 Requires-Dist: pyside6; extra == "pyside"
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 [![Ubuntu unit tests](https://github.com/myokit/myokit/actions/workflows/unit-tests-ubuntu.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-ubuntu.yml)
 [![MacOS unit tests](https://github.com/myokit/myokit/actions/workflows/unit-tests-macos.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-macos.yml)
@@ -51,6 +64,8 @@ Requires-Dist: pyside6; extra == "pyside"
 [![Windows Miniconda test](https://github.com/myokit/myokit/actions/workflows/unit-tests-windows-miniconda.yml/badge.svg)](https://github.com/myokit/myokit/actions/workflows/unit-tests-windows-miniconda.yml)
 [![codecov](https://codecov.io/gh/myokit/myokit/branch/main/graph/badge.svg)](https://codecov.io/gh/myokit/myokit)
 [![Documentation Status](https://readthedocs.org/projects/myokit/badge/?version=latest)](https://myokit.readthedocs.io/?badge=latest)
+[![pypi](https://img.shields.io/pypi/v/myokit)](https://pypi.org/project/myokit/)
+[![anaconda](https://anaconda.org/conda-forge/myokit/badges/version.svg)](https://anaconda.org/conda-forge/myokit)
 
 ![Myokit](https://myokit.org/static/img/logo.png)