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

myokit/tests/test_formats_stan.py

@@ -0,0 +1,175 @@
+#!/usr/bin/env python3
+#
+# Tests writing of Stan equations.
+#
+# This file is part of Myokit.
+# See http://myokit.org for copyright, sharing, and licensing details.
+#
+import unittest
+
+import myokit
+import myokit.formats.stan
+
+from myokit import (
+    Number, PrefixPlus, PrefixMinus, Plus, Minus,
+    Multiply, Divide, Quotient, Remainder, Power, Sqrt,
+    Exp, Log, Log10, Sin, Cos, Tan, ASin, ACos, ATan, Floor, Ceil, Abs,
+    Not, And, Or, Equal, NotEqual, More, Less, MoreEqual, LessEqual,
+    If, Piecewise,
+)
+
+import myokit.tests
+
+
+class StanExpressionWriterTest(myokit.tests.ExpressionWriterTestCase):
+    """ Test conversion of expressions to Stan. """
+    _name = 'stan'
+    _target = myokit.formats.stan.StanExpressionWriter
+
+    def test_number(self):
+        self.eq(Number(1), '1.0')
+        self.eq(Number(-1.3274924373284374), '-1.32749243732843736e+00')
+        self.eq(Number(+1.3274924373284374), '1.32749243732843736e+00')
+        self.eq(Number(-2), '-2.0')
+        self.eq(Number(13, 'mV'), '13.0')
+
+    def test_name(self):
+        self.eq(self.a, 'a')
+        w = self._target()
+        w.set_lhs_function(lambda v: v.var().qname().upper())
+        self.assertEqual(w.ex(self.a), 'COMP.A')
+
+    def test_derivative(self):
+        self.eq(myokit.Derivative(self.a), 'dot(a)')
+
+    def test_partial_derivative(self):
+        e = myokit.PartialDerivative(self.a, self.b)
+        self.assertRaisesRegex(NotImplementedError, 'Partial', self.w.ex, e)
+
+    def test_initial_value(self):
+        e = myokit.InitialValue(self.a)
+        self.assertRaisesRegex(NotImplementedError, 'Initial', self.w.ex, e)
+
+    def test_prefix_plus_minus(self):
+        # Test with numbers
+        p = Number(11, 'kV')
+        self.eq(PrefixPlus(p), '+11.0')
+        self.eq(PrefixPlus(PrefixPlus(p)), '++11.0')
+        self.eq(PrefixMinus(p), '-11.0')
+        self.eq(PrefixMinus(PrefixMinus(p)), '--11.0')
+        self.eq(PrefixMinus(Number(-1)), '--1.0')
+
+        a, b, c = self.abc
+        self.eq(PrefixMinus(Plus(a, b)), '-(a + b)')
+        self.eq(Divide(PrefixPlus(Plus(a, b)), c), '+(a + b) / c')
+        self.eq(Power(PrefixMinus(a), b), '(-a)^b')
+        self.eq(Power(PrefixPlus(Power(b, a)), c), '(+b^a)^c')
+        self.eq(Power(a, PrefixMinus(Power(b, c))), 'a^(-b^c)')
+
+    def test_plus_minus(self):
+        a, b, c = self.abc
+        self.eq(Plus(a, b), 'a + b')
+        self.eq(Plus(Plus(a, b), c), 'a + b + c')
+        self.eq(Plus(a, Plus(b, c)), 'a + (b + c)')
+        self.eq(Minus(a, b), 'a - b')
+        self.eq(Minus(Minus(a, b), c), 'a - b - c')
+        self.eq(Minus(a, Minus(b, c)), 'a - (b - c)')
+        self.eq(Minus(a, b), 'a - b')
+        self.eq(Plus(Minus(a, b), c), 'a - b + c')
+        self.eq(Minus(a, Plus(b, c)), 'a - (b + c)')
+        self.eq(Minus(Plus(a, b), c), 'a + b - c')
+        self.eq(Minus(a, Plus(b, c)), 'a - (b + c)')
+
+    def test_multiply_divide(self):
+        a, b, c = self.abc
+        self.eq(Multiply(a, b), 'a * b')
+        self.eq(Multiply(Multiply(a, b), c), 'a * b * c')
+        self.eq(Multiply(a, Multiply(b, c)), 'a * (b * c)')
+        self.eq(Divide(a, b), 'a / b')
+        self.eq(Divide(Divide(a, b), c), 'a / b / c')
+        self.eq(Divide(a, Divide(b, c)), 'a / (b / c)')
+
+        self.eq(Divide(Multiply(a, b), c), 'a * b / c')
+        self.eq(Multiply(Divide(a, b), c), 'a / b * c')
+        self.eq(Divide(a, Multiply(b, c)), 'a / (b * c)')
+        self.eq(Multiply(a, Divide(b, c)), 'a * (b / c)')
+
+        self.eq(Multiply(Minus(a, b), c), '(a - b) * c')
+        self.eq(Divide(a, Plus(b, c)), 'a / (b + c)')
+        self.eq(Minus(Multiply(a, b), c), 'a * b - c')
+        self.eq(Plus(a, Divide(b, c)), 'a + b / c')
+
+    def test_quotient_remainder(self):
+        a, b, c = self.abc
+
+        self.eq(Quotient(c, a), 'floor(c / a)')
+        self.eq(Remainder(c, a), '(c - a * floor(c / a))')
+
+    def test_power(self):
+        a, b, c = self.abc
+        self.eq(Power(a, b), 'a^b')
+        self.eq(Power(Plus(a, b), c), '(a + b)^c')
+        self.eq(Power(a, Minus(b, c)), 'a^(b - c)')
+        self.eq(Power(Multiply(a, b), c), '(a * b)^c')
+        self.eq(Power(a, Divide(b, c)), 'a^(b / c)')
+
+        # Stan has a right-associative power operator, so must add brackets
+        # to get Myokit behavuour
+        self.eq(Power(Power(a, b), c), '(a^b)^c')
+        self.eq(Power(a, Power(b, c)), 'a^b^c')
+
+    def test_functions(self):
+        a, b = self.ab
+
+        self.eq(Sqrt(a), 'sqrt(a)')
+        self.eq(Exp(a), 'exp(a)')
+        self.eq(Log(a), 'log(a)')
+        self.eq(Log(a, b), '(log(a) / log(b))')
+        self.eq(Log10(a), 'log10(a)')
+        self.eq(Sin(a), 'sin(a)')
+        self.eq(Cos(a), 'cos(a)')
+        self.eq(Tan(a), 'tan(a)')
+        self.eq(ASin(a), 'asin(a)')
+        self.eq(ACos(a), 'acos(a)')
+        self.eq(ATan(a), 'atan(a)')
+        self.eq(Floor(a), 'floor(a)')
+        self.eq(Ceil(a), 'ceil(a)')
+        self.eq(Abs(a), 'abs(a)')
+
+    def test_conditions(self):
+        a, b, c, d = self.abcd
+
+        self.eq(And(a, b), '(a && b)')
+        self.eq(Or(d, c), '(d || c)')
+        self.eq(Not(c), '(!c)')
+
+        self.eq(Equal(a, b), '(a == b)')
+        self.eq(NotEqual(a, b), '(a != b)')
+        self.eq(More(b, a), '(b > a)')
+        self.eq(Less(d, c), '(d < c)')
+        self.eq(MoreEqual(c, a), '(c >= a)')
+        self.eq(LessEqual(b, d), '(b <= d)')
+
+        self.eq(And(Equal(a, b), NotEqual(c, d)), '((a == b) && (c != d))')
+        self.eq(Or(More(d, c), Less(b, a)), '((d > c) || (b < a))')
+        self.eq(Not(Equal(d, d)), '(!(d == d))')
+        self.eq(Not(Or(Number(1), Number(2))), '(!(1.0 || 2.0))')
+
+        self.eq(Equal(Equal(Number(0), Number(0)), Number(0)),
+                '((0.0 == 0.0) == 0.0)')
+
+    def test_conditionals(self):
+        a, b, c, d = self.abcd
+        self.eq(If(Equal(a, b), d, c), '((a == b) ? d : c)')
+        self.eq(Piecewise(NotEqual(d, c), b, a), '((d != c) ? b : a)')
+        self.eq(Piecewise(Equal(a, b), c, Equal(a, d), Number(3), Number(4)),
+                '((a == b) ? c : ((a == d) ? 3.0 : 4.0))')
+
+        # Extra parentheses if condition is not a condition
+        self.eq(If(a, d, c), '(a ? d : c)')
+        self.eq(Piecewise(a, b, c, d, Number(4)),
+                '(a ? b : (c ? d : 4.0))')
+
+
+if __name__ == '__main__':
+    unittest.main()

myokit/tests/test_formats_sympy.py

@@ -64,6 +64,9 @@ class SymPyReadWriteTest(unittest.TestCase):
         self.assertEqual(w.ex(x), cb)
         # Note: Sympy doesn't seem to have a prefix plus
         self.assertEqual(r.ex(cb), b)
+        x = myokit.Divide(myokit.PrefixPlus(myokit.Plus(a, b)), self._b)
+        y = r.ex(w.ex(x))
+        self.assertEqual(y.code(), 'c.b^-1 * (12 + c.a)')
 
         # Prefix minus
         # Note: SymPy treats -x as Mul(NegativeOne, x)
@@ -105,8 +108,12 @@ class SymPyReadWriteTest(unittest.TestCase):
 
         # Power
         x = myokit.Power(a, b)
-        self.assertEqual(w.ex(x), ca ** cb)
-        self.assertEqual(float(r.ex(ca ** cb)), float(x))
+        self.assertEqual(w.ex(x), ca**cb)
+        self.assertEqual(float(r.ex(ca**cb)), float(x))
+        x = myokit.Power(myokit.Power(a, b), self._b)
+        self.assertEqual(w.ex(x), (ca**cb)**sp.Symbol('c.b'))
+        x = myokit.Power(a, myokit.Power(b, self._b))
+        self.assertEqual(w.ex(x), ca**(cb**sp.Symbol('c.b')))
 
         # Sqrt
         x = myokit.Sqrt(a)

myokit/tests/test_lib_hh.py

@@ -15,6 +15,8 @@ import myokit.lib.hh as hh
 
 from myokit.tests import DIR_DATA
 
+from myokit.tests import WarningCollector
+
 
 MODEL = """
 [[model]]
@@ -914,6 +916,40 @@ class AnalyticalSimulationTest(unittest.TestCase):
         e = np.abs(d1['binding.I'] - d2['binding.I'])
         self.assertLess(np.max(e), 2e-4)
 
+    def test_tau_overflow(self):
+        # Overflows leading to tau=0 should still report current
+        # https://github.com/myokit/myokit/issues/1059
+
+        # Load model and convert to inf-tau form
+        fname = os.path.join(DIR_DATA, 'lr-1991-fitting.mmt')
+        model = hh.convert_hh_states_to_inf_tau_form(myokit.load_model(fname))
+
+        # Get initial state and set steady state
+        initial_state = model.get('ina.m').initial_value(as_float=True)
+        steady_state = 0.75
+        model.get('ina.m.inf').set_rhs(steady_state)
+
+        # Create an analytical simulation
+        model = hh.HHModel(model, states=['ina.m', 'ina.h', 'ina.j'],
+                           parameters=['ina.p5'], current='ina.INa')
+        p = myokit.pacing.steptrain_linear(20, 40, 10, -80, 10, 10)
+        s = hh.AnalyticalSimulation(model, protocol=p)
+
+        # Setting p5=0.001 will trigger an overflow in ina.m.beta
+        s.set_parameters([0.001])
+        with WarningCollector() as wc:
+            # Log times chosen so that s._function varies length of _t
+            log = s.run(41, log_times=np.array([0, 1, 2, 10, 11, 12, 20, 40]))
+        self.assertIn('overflow', wc.text())
+
+        # Should be no NaNs in log
+        self.assertFalse(np.any(np.isnan(log['ina.INa'])))
+        self.assertFalse(np.any(np.isnan(log['ina.m'])))
+
+        # Should immediately jump from initial state to steady state
+        self.assertTrue(log['ina.m'][0] == initial_state)
+        self.assertTrue(np.all(log['ina.m'][1:] == steady_state))
+
 
 if __name__ == '__main__':
     unittest.main()

myokit/tests/test_lib_plots.py

@@ -41,14 +41,12 @@ class LibPlotTest(unittest.TestCase):
         # Stair
         fig = plt.figure()
         plots.simulation_times(st, rt, ev, 'stair')
-        plt.show()
         plt.close(fig)
         self.assertRaises(ValueError, plots.simulation_times, mode='stair')
 
         # Inverse stair
         fig = plt.figure()
         plots.simulation_times(st, rt, ev, 'stair_inverse')
-        plt.show()
         plt.close(fig)
         self.assertRaises(
             ValueError, plots.simulation_times, mode='stair_inverse')
@@ -56,21 +54,18 @@ class LibPlotTest(unittest.TestCase):
         # Load
         fig = plt.figure()
         plots.simulation_times(st, rt, ev, 'load')
-        plt.show()
         plt.close(fig)
         self.assertRaises(ValueError, plots.simulation_times, mode='load')
 
         # Histogram
         fig = plt.figure()
         plots.simulation_times(st, rt, ev, 'histo')
-        plt.show()
         plt.close(fig)
         self.assertRaises(ValueError, plots.simulation_times, mode='histo')
 
         # Time per step
         fig = plt.figure()
         plots.simulation_times(st, rt, ev, 'time_per_step')
-        plt.show()
         plt.close(fig)
         self.assertRaises(
             ValueError, plots.simulation_times, mode='time_per_step')
@@ -78,7 +73,6 @@ class LibPlotTest(unittest.TestCase):
         # Evaluations per step
         fig = plt.figure()
         plots.simulation_times(st, rt, ev, 'eval_per_step')
-        plt.show()
         plt.close(fig)
         self.assertRaises(
             ValueError, plots.simulation_times, mode='eval_per_step')
@@ -111,7 +105,6 @@ class LibPlotTest(unittest.TestCase):
         fig = plt.figure()
         plots.current_arrows(d, 'membrane.V', currents)
         plt.close(fig)
-        plt.show()
 
         # Massive peak at final point
         d = d.npview()
@@ -119,7 +112,6 @@ class LibPlotTest(unittest.TestCase):
         fig = plt.figure()
         plots.current_arrows(d, 'membrane.V', currents)
         plt.close(fig)
-        plt.show()
 
     def test_cumulative_current(self):
         # Test the cumulative current plot.
@@ -140,7 +132,6 @@ class LibPlotTest(unittest.TestCase):
         plots.cumulative_current(d, currents)
         plt.legend()
         plt.close(fig)
-        plt.show()
 
         # Labels set
         labels = ['I_Ca', 'I_K', 'I_K1', 'I_Kp', 'I_b']
@@ -148,7 +139,6 @@ class LibPlotTest(unittest.TestCase):
         plots.cumulative_current(d, currents, labels=labels)
         plt.legend()
         plt.close(fig)
-        plt.show()
 
         # Colors set
         colors = ['green', 'blue', 'yellow', 'brown', 'gray']
@@ -156,7 +146,6 @@ class LibPlotTest(unittest.TestCase):
         plots.cumulative_current(d, currents, colors=colors)
         plt.legend()
         plt.close(fig)
-        plt.show()
 
         # Not enough colors set (will repeat array)
         colors = ['green', 'blue']
@@ -164,35 +153,30 @@ class LibPlotTest(unittest.TestCase):
         plots.cumulative_current(d, currents, colors=colors)
         plt.legend()
         plt.close(fig)
-        plt.show()
 
         # Integrate currents to charges
         fig = plt.figure()
         plots.cumulative_current(d, currents, integrate=True)
         plt.legend()
         plt.close(fig)
-        plt.show()
 
         # Normalize currents
         fig = plt.figure()
         plots.cumulative_current(d, currents, normalize=True)
         plt.legend()
         plt.close(fig)
-        plt.show()
 
         # Normalize currents and set maximum number of currents shown
         fig = plt.figure()
         plots.cumulative_current(d, currents, normalize=True, max_currents=3)
         plt.legend()
         plt.close(fig)
-        plt.show()
 
         with WarningCollector() as w:
             fig = plt.figure()
             plots.cumulative_current(d, currents, normalise=True)
             plt.legend()
             plt.close(fig)
-            plt.show()
         self.assertIn('deprecated', w.text())
 
 

myokit/tests/test_model.py

@@ -438,6 +438,7 @@ class ModelTest(unittest.TestCase):
         b = component.add_variable('b')
         c = component.add_variable('c')
         d = component.add_variable('d')
+        e = component.add_variable('e')
         a.promote(1)
         a.set_rhs('1')
         b.promote(2)
@@ -445,6 +446,7 @@ class ModelTest(unittest.TestCase):
         c.promote(3)
         c.set_rhs('b + d')
         d.set_rhs('1 * c')
+        e.set_rhs(0)
         model.validate()
 
         # Test without input
@@ -476,13 +478,31 @@ class ModelTest(unittest.TestCase):
             model.evaluate_derivatives(
                 state=[2, 3, 4], inputs={'time': 10}, ignore_errors=True),
             [1, 6, 17])
+        d.set_rhs(10)
+        e.set_rhs(20)
+        d.set_binding('realtime')
+        e.set_binding('evaluations')
+        c.set_rhs('d + e + time')
+        self.assertEqual(model.evaluate_derivatives(), [1, 4, 31])
+        self.assertEqual(
+            model.evaluate_derivatives(inputs={'evaluations': 1.2}),
+            [1, 4, 12.2])
+        e.set_binding(None)
+        self.assertEqual(model.evaluate_derivatives(), [1, 4, 31])
+        e.set_binding('pace')
+        self.assertEqual(model.evaluate_derivatives(), [1, 4, 31])
+        self.assertEqual(
+            model.evaluate_derivatives(inputs={'pace': 10}), [1, 4, 21])
+        self.assertEqual(
+            model.evaluate_derivatives(inputs={'pace': 10, 'time': 20}),
+            [1, 4, 40])
 
         # Deprecated name
         with WarningCollector() as w:
             self.assertEqual(
                 model.eval_state_derivatives(
                     state=[1, 1, 2], inputs={'time': 0}),
-                [1, 2, 3])
+                [1, 2, 30])
         self.assertIn('deprecated', w.text())
 
         # Ignoring errors should lead to Nans

myokit/tests/test_simulation_cvodes.py

@@ -522,21 +522,62 @@ class SimulationTest(unittest.TestCase):
             ValueError, 'no `apd_variable` specified',
             self.sim.run, 1, apd_threshold=12)
 
-    def test_last_state(self):
-        # Returns the last state before an error, or None.
+    def test_crash_state_and_inputs(self):
+        # Tests Simulation.crash_state
 
         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.last_state())
+        self.assertIsNone(s.crash_state())
+        self.assertIsNone(s.crash_inputs())
         s.run(1)
-        self.assertIsNone(s.last_state())
+        self.assertIsNone(s.crash_state())
         s.set_constant('membrane.i_stim.stim_amplitude', 0)
         s.reset()
         self.assertRaisesRegex(myokit.SimulationError, "at t = 0", s.run, 5)
-        self.assertEqual(len(s.last_state()), len(s.state()))
-        self.assertEqual(s.last_state(), s.state())
+        self.assertEqual(s.crash_state(), s.state())
+        self.assertEqual(
+            set(s.crash_inputs()), {'time', 'pace', 'realtime', 'evaluations'})
+        t = s.crash_inputs()['time']
+        self.assertEqual(s.crash_inputs()['time'], 0)
+        self.assertEqual(s.crash_inputs()['pace'], 0)
+        self.assertGreaterEqual(s.crash_inputs()['realtime'], 0)
+        self.assertGreater(s.crash_inputs()['evaluations'], 0)
+        '''
+
+        # Test crash at later time
+        istim.set_rhs('if(engine.time == 5, 1 / (5 - engine.time), 0)')
+        # Ensure t=5 is visited
+        p = myokit.pacing.blocktrain(duration=0.1, period=5)
+        # Test evaluations and realtime only present if used
+        m.binding('evaluations').set_binding(None)
+        s = myokit.Simulation(m, p)
+        with myokit.tools.capture():
+            self.assertRaisesRegex(myokit.SimulationError, 'CV_CONV', s.run, 6)
+        self.assertEqual(
+            set(s.crash_inputs()), {'time', 'pace', 'realtime'})
+        self.assertEqual(s.crash_inputs()['time'], 5)
+        self.assertEqual(s.crash_inputs()['pace'], 1)
+        self.assertGreater(s.crash_inputs()['realtime'], 0)
+
+        # Above should both crash via cvode flag set. Next should be halted by
+        # C code for too many zero steps
+        istim.set_rhs('1 / (5 - engine.time)')
+        s = myokit.Simulation(m, p)
+        with myokit.tools.capture():
+            self.assertRaisesRegex(
+                myokit.SimulationError, 'zero-length', s.run, 6)
+        self.assertAlmostEqual(s.crash_inputs()['time'], 5)
+        self.assertEqual(s.crash_inputs()['pace'], 1)
+        self.assertGreater(s.crash_inputs()['realtime'], 0)
+
+        # Test deprecated alias of crash_state
+        x = s.crash_state()
+        with WarningCollector() as w:
+            self.assertEqual(s.last_state(), x)
+        self.assertIn('eprecated', w.text())
 
     def test_last_evaluations_and_steps(self):
         # Test :meth:`Simulation.last_number_of_evaluations()` and
@@ -591,59 +632,99 @@ class SimulationTest(unittest.TestCase):
         self.assertEqual(s[0][0], 1)
         self.assertEqual(s[1][0], 0)
 
-    def test_eval_derivatives(self):
-        # Test :meth:`Simulation.eval_derivatives()`.
+    def test_evaluate_derivatives(self):
+        # Test :meth:`Simulation.evaluate_derivatives()`.
 
+        m = myokit.Model()
+        z = m.add_component('z')
+        t = z.add_variable('t', rhs=0, binding='time')
+        a = z.add_variable('a', rhs=1, binding='pace')
+        b = z.add_variable('b', rhs=2, binding='pace1')
+        c = z.add_variable('c', rhs=4, binding='pace2')
+        d = z.add_variable('d', rhs=8, binding='evaluations')
+        e = z.add_variable('e', rhs=12, binding='realtime')
+        f = z.add_variable('f', rhs=100)
+        p = z.add_variable('p', rhs='p+t+a+b+c+d+e+f', initial_value=0)
+        q = z.add_variable('q', rhs='p + q', initial_value=1)
+
+        sim = myokit.Simulation(m)
+
+        # Test without input
+        self.assertEqual(sim.evaluate_derivatives(), [106, 1])
+
+        # Test with new state
+        self.assertEqual(sim.evaluate_derivatives([1, 2]), [107, 3])
+
+        # Test with changed constant
+        sim.set_constant('z.f', 200)
+        self.assertEqual(sim.evaluate_derivatives(), [206, 1])
+        sim.set_constant('z.f', 300)
+        self.assertEqual(sim.evaluate_derivatives([1, 2]), [307, 3])
+        sim.set_constant('z.f', 0)
+        self.assertEqual(sim.evaluate_derivatives([1, 2]), [7, 3])
+
+        # Test with inputs
+        d = {'time': 1}
+        self.assertEqual(sim.evaluate_derivatives([1, 2], d), [8, 3])
+        d = {'time': 2}
+        self.assertEqual(sim.evaluate_derivatives([1, 2], d), [9, 3])
+        d = {'time': 2, 'evaluations': 3}
+        self.assertEqual(sim.evaluate_derivatives([1, 2], d), [12, 3])
+        d = {'time': 2, 'evaluations': 3, 'realtime': 1.23}
+        self.assertEqual(sim.evaluate_derivatives([1, 2], d), [13.23, 3])
+
+        # Test with unknown inputs
+        d = {'toime': 1}
+        self.assertRaisesRegex(ValueError, 'Unknown binding or',
+                               sim.evaluate_derivatives, [1, 2], d)
+
+        # Test with pacing: not passed on to sim
+        sim.set_protocol(myokit.pacing.constant(1000))
+
+        # Running doesn't change anything
+        self.assertEqual(sim.evaluate_derivatives(), [6, 1])
+        sim.run(1)
+        self.assertEqual(sim.evaluate_derivatives(), [6, 1])
+        self.assertEqual(sim.evaluate_derivatives([2, 3]), [8, 5])
+        sim.run(10)
+        self.assertEqual(sim.evaluate_derivatives(), [6, 1])
+        self.assertEqual(sim.evaluate_derivatives([2, 3]), [8, 5])
+        sim.reset()
+        self.assertEqual(sim.evaluate_derivatives([2, 3]), [8, 5])
+        d = {'time': 123}
+        self.assertEqual(sim.evaluate_derivatives([2, 3], d), [131, 5])
+
+        # Changing the pacing labels
+        d = {'pace': 1000}
+        self.assertEqual(sim.evaluate_derivatives(inputs=d), [1006, 1])
+        d = {'pace1': 1}
+        self.assertRaisesRegex(ValueError, 'Unknown binding or',
+                               sim.evaluate_derivatives, inputs=d)
+
+        sim = myokit.Simulation(m, {
+            'pace1': myokit.pacing.constant(1000),
+            'pace2': myokit.pacing.constant(2000)})
+        d = {'pace': 1}
+        self.assertRaisesRegex(ValueError, 'Unknown binding or',
+                               sim.evaluate_derivatives, [1, 2], d)
+        self.assertEqual(sim.evaluate_derivatives(), [101, 1])
+        d = {'pace1': 100}
+        self.assertEqual(sim.evaluate_derivatives(inputs=d), [201, 1])
+        d = {'pace2': 200}
+        self.assertEqual(sim.evaluate_derivatives(inputs=d), [301, 1])
+        d = {'pace1': 123, 'pace2': 200}
+        self.assertEqual(sim.evaluate_derivatives(inputs=d), [424, 1])
+
+        # Test deprecated method
         self.sim.reset()
-        s1 = self.sim.state()
-        d1 = self.sim.eval_derivatives()
+        d1 = self.sim.evaluate_derivatives()
+        with WarningCollector() as w:
+            self.assertEqual(self.sim.eval_derivatives(), d1)
+        self.assertIn('eprecated', w.text())
+        # ...which uses state() instead of default state
         self.sim.run(1)
-        d2 = self.sim.eval_derivatives()
-        self.assertNotEqual(d1, d2)
-        self.assertEqual(d1, self.sim.eval_derivatives(s1))
-        self.sim.set_state(s1)
-        self.assertEqual(d1, self.sim.eval_derivatives())
-
-    def test_eval_derivatives_with_pacing(self):
-        # Test :meth:`Simulation.eval_derivatives()`.
-
-        model = myokit.Model()
-        c = model.add_component('c')
-
-        a = c.add_variable('a')
-        a.set_binding('a')
-        a.set_rhs(0)
-        b = c.add_variable('b')
-        b.set_binding('b')
-        b.set_rhs(0)
-
-        y = c.add_variable('y')
-        t = c.add_variable('t')
-        t.set_binding('time')
-        t.set_rhs(0)
-        y.promote(1)
-        y.set_rhs('- a * y - b * y')
-
-        pa = myokit.Protocol()
-        pa.schedule(1, 0, 0.5)
-
-        pb = myokit.Protocol()
-        pb.schedule(2, 1.0, 0.5)
-
-        sim = myokit.Simulation(model, {'a': pa, 'b': pb})
-        sim.run(1)
-        d1 = sim.eval_derivatives(pacing={'a': 0.5, 'b': 0.5})
-        d2 = sim.eval_derivatives(pacing={'a': 1.5, 'b': 0.5})
-        self.assertNotEqual(d1, d2)
-        d1 = sim.eval_derivatives(pacing={'b': 0.5})
-        d2 = sim.eval_derivatives(pacing={'a': 0.0, 'b': 0.5})
-        self.assertEqual(d1, d2)
-        d1 = sim.eval_derivatives()
-        d2 = sim.eval_derivatives(pacing={'a': 0.0, 'b': 0.0})
-        self.assertEqual(d1, d2)
-        d1 = sim.eval_derivatives(pacing={'a': 0.0, 'b': 0.5})
-        d2 = sim.eval_derivatives(pacing={'aaaaa': 1.0, 'b': 0.5})
-        self.assertEqual(d1, d2)
+        with WarningCollector() as w:
+            self.assertNotEqual(self.sim.eval_derivatives(), d1)
 
     def test_sensitivities_initial(self):
         # Test setting initial sensitivity values.

myokit/tools.py

@@ -23,7 +23,8 @@ _natural_sort_regex = re.compile('([0-9]+)')
 
 class Benchmarker:
     """
-    Allows benchmarking using the with statement.
+    Provides reasonably precise benchmarking (with times obtained from
+    ``timeit.default_timer()``) and formats times.
 
     Example::
 
@@ -34,7 +35,7 @@ class Benchmarker:
         print(b.time())
         b.reset()
         s.run()
-        print(b.time())
+        print(b.format())
 
     """
     def __init__(self):

{myokit-1.35.4.dist-info → myokit-1.36.1.dist-info}/LICENSE.txt

@@ -3,7 +3,7 @@ BSD 3-Clause License
 Copyright (c) 2011-2017 Maastricht University. All rights reserved.
 Copyright (c) 2017-2020 University of Oxford. All rights reserved.
 (University of Oxford means the Chancellor, Masters and Scholars of the University of Oxford, having an administrative office at Wellington Square, Oxford OX1 2JD, UK).
-Copyright (c) 2020-2023 University of Nottingham. All rights reserved.
+Copyright (c) 2020-2024 University of Nottingham. All rights reserved.
 
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are met: