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

myokit/tests/test_cellml_v2_api.py

@@ -851,6 +851,65 @@ class TestCellML2ModelConversion(unittest.TestCase):
         mm = cm.myokit_model()
         self.assertEqual(mm.get('c.y').eval(), 6.2)
 
+    def test_m2c_initial_values(self):
+        # Test conversion of initial values
+
+        m = myokit.parse_model('''
+            [[model]]
+            x.a = 1e3
+            x.b = -1       # parsed as PrefixMinus(Number(1))
+            x.c = --+-+-5  # extreme case of same
+            x.d = 1 + sqrt(4)
+            x.e = x.p
+            x.f = x.p + 3
+            x.g = y.q
+
+            [x]
+            t = 0 bind time
+            dot(a) = 0
+            dot(b) = 1
+            dot(c) = 2
+            dot(d) = 3
+            dot(e) = 4
+            dot(f) = 5
+            dot(g) = 6
+            p = 12
+            g_init = 0
+
+            [y]
+            q = 13
+        ''')
+        self.assertIsInstance(m.get('x.b').initial_value(), myokit.PrefixMinus)
+
+        with WarningCollector() as w:
+            cm = cellml.Model.from_myokit_model(m)
+        self.assertFalse(w.has_warnings())
+        a, b, c, d, e, f, g, p = [cm['x'][i] for i in 'abcdefgp']
+        di = cm['x']['d_init']
+        fi = cm['x']['f_init']
+        gi = cm['x']['g_init_1']
+        self.assertEqual(a.initial_value(), myokit.Number(1e3))
+        self.assertEqual(b.initial_value(), myokit.Number(-1))
+        self.assertEqual(c.initial_value(), myokit.Number(5))
+        self.assertEqual(d.initial_value(), myokit.Name(di))
+        self.assertEqual(e.initial_value(), myokit.Name(p))
+        self.assertEqual(f.initial_value(), myokit.Name(fi))
+        self.assertEqual(g.initial_value(), myokit.Name(gi))
+        self.assertEqual(
+            fi.rhs(), myokit.Plus(myokit.Name(p), myokit.Number(3)))
+        # Note: ei has rhs x.q, not y.q, because connections!
+        self.assertEqual(gi.rhs(), myokit.Name(cm['x']['q']))
+        self.assertEqual(cm['x']['q'].interface(), 'public')
+        self.assertEqual(a.rhs(), myokit.Number(0))
+        self.assertEqual(b.rhs(), myokit.Number(1))
+        self.assertEqual(c.rhs(), myokit.Number(2))
+        self.assertEqual(d.rhs(), myokit.Number(3))
+        self.assertEqual(e.rhs(), myokit.Number(4))
+        self.assertEqual(f.rhs(), myokit.Number(5))
+        self.assertEqual(g.rhs(), myokit.Number(6))
+        cm.validate()
+        del di, fi, gi
+
     def test_m2c_oxmeta(self):
         # Test that oxmeta data is passed on when creating a CellML model.
 
@@ -929,7 +988,13 @@ class TestCellML2ModelConversion(unittest.TestCase):
         m.add_connection(x, xb)
         m.add_connection(xc, xb)
         z2 = c.add_variable('z2', 'metre')
-        z2.set_initial_value(4)
+        z3 = c.add_variable('z3', 'metre')
+        m.add_units(
+            'meter_per_second', myokit.units.meter / myokit.units.second)
+        z2.set_equation(myokit.Equation(
+            myokit.Derivative(myokit.Name(z2)), myokit.Number(1.23, 'm/s')))
+        z2.set_initial_value('z3')
+        z3.set_initial_value(13)
         t = a.add_variable('t', 'second')
         t.meta['yes'] = 'no'
         m.set_variable_of_integration(t)
@@ -952,7 +1017,7 @@ class TestCellML2ModelConversion(unittest.TestCase):
         self.assertEqual(mm.name(), 'm')
 
         # Check meta data is added
-        self.assertIn('author', mm.meta)
+        self.assertIn('mmt_authors', mm.meta)
 
         # Check meta data is passed on
         self.assertIn('documentation', mm.meta)
@@ -963,20 +1028,16 @@ class TestCellML2ModelConversion(unittest.TestCase):
         self.assertEqual(mm.get('a.t').meta['yes'], 'no')
 
         # Check components are present
-        ma = mm['a']
-        mb = mm['b']
-        mc = mm['c']
+        ma, mb, mc = mm['a'], mm['b'], mm['c']
         self.assertEqual(len(mm), 3)
 
         # Check variables are present
-        mt = ma['t']
-        mx = ma['x']
+        mt, mx = ma['t'], ma['x']
         self.assertEqual(len(ma), 2)
         my = mb['y']
         self.assertEqual(len(mb), 1)
-        mz = mc['z']
-        mz2 = mc['z2']
-        self.assertEqual(len(mc), 2)
+        mz, mz2, mz3 = mc['z'], mc['z2'], mc['z3']
+        self.assertEqual(len(mc), 3)
 
         # Check units are set
         self.assertEqual(mt.unit(), myokit.units.second)
@@ -994,7 +1055,9 @@ class TestCellML2ModelConversion(unittest.TestCase):
         self.assertEqual(
             mz.rhs(),
             myokit.Plus(myokit.Number(3, myokit.units.volt), myokit.Name(mx)))
-        self.assertEqual(mz2.rhs(), myokit.Number(4, myokit.units.meter))
+        self.assertEqual(mz3.rhs(), myokit.Number(13, myokit.units.meter))
+        self.assertEqual(mz2.rhs(), myokit.Number(1.23, 'm/s'))
+        self.assertEqual(mz2.initial_value(), myokit.Name(mz3))
 
         # Check state
         self.assertTrue(mx.is_state())
@@ -1314,27 +1377,74 @@ class TestCellML2Variable(unittest.TestCase):
         m.add_units('millivolt', myokit.units.mV)
         c = m.add_component('c1')
         x = c.add_variable('bart', 'volt', 'public')
+        y = c.add_variable('bort', 'volt')
+        y.set_initial_value(1)
+        z = c.add_variable('burt', 'ampere')
+        z.set_initial_value(0)
+        d = m.add_component('c2')
+        p = d.add_variable('birt', 'volt', 'public')
 
         # Not set yet
         self.assertIsNone(x.initial_value())
 
-        # Set with float
+        # Set with number type
         x.set_initial_value(3)
         self.assertTrue(x.has_initial_value())
-        self.assertEqual(x.initial_value(), myokit.Number(3, myokit.units.V))
+        self.assertEqual(
+            x.initial_value(), myokit.Number(3, myokit.units.volt))
+
+        # If using Number, the units must be correct
+        self.assertRaisesRegex(
+            cellml.CellMLError, 'must have the same units',
+            x.set_initial_value, myokit.Number(2, myokit.units.dimensionless))
+        x.set_initial_value(myokit.Number(1, myokit.units.volt))
+        self.assertEqual(
+            x.initial_value(), myokit.Number(1, myokit.units.volt))
 
-        # Unit is ignored
-        x.set_initial_value(myokit.Number(2, myokit.units.dimensionless))
-        self.assertEqual(x.initial_value(), myokit.Number(2, myokit.units.V))
+        # Prefix operators are fine
+        x.set_initial_value(myokit.PrefixMinus(myokit.PrefixPlus(
+            myokit.Number(1.23, myokit.units.volt))))
+        self.assertEqual(
+            x.initial_value(), myokit.Number(-1.23, myokit.units.volt))
 
         # Unset
         x.set_initial_value(None)
         self.assertIsNone(x.initial_value())
 
-        # Set with other than a number
+        # Local names are allowed
+        x.set_initial_value(myokit.Name(y))
+        self.assertEqual(x.initial_value(), myokit.Name(y))
         self.assertRaisesRegex(
-            cellml.CellMLError, 'must be a real number',
-            x.set_initial_value, 'twelve')
+            cellml.CellMLError, 'Non-local variable',
+            x.set_initial_value, myokit.Name(p))
+        self.assertRaisesRegex(
+            cellml.CellMLError, 'Unknown local variable',
+            x.set_initial_value, 'brrr')
+
+        # Strings are allowed
+        x.set_initial_value('-1')
+        self.assertEqual(
+            x.initial_value(), myokit.Number(-1, myokit.units.volt))
+        x.set_initial_value('3.21e4')
+        self.assertEqual(
+            x.initial_value(), myokit.Number(3.21e4, myokit.units.volt))
+        x.set_initial_value('bort')
+        self.assertEqual(x.initial_value(), myokit.Name(y))
+        self.assertRaisesRegex(
+            cellml.CellMLError, 'If given, a variable initial_value',
+            x.set_initial_value, '@hello')
+
+        # Set with expression other than a number or name
+        self.assertRaisesRegex(
+            cellml.CellMLError, 'must be a real number or a local variable',
+            x.set_initial_value, myokit.Plus(
+                myokit.Number(1, myokit.units.volt),
+                myokit.Number(2, myokit.units.volt)))
+
+        # Set with unhandled type
+        self.assertRaisesRegex(
+            cellml.CellMLError, 'must be a real number or a local variable',
+            x.set_initial_value, self)
 
     def test_initial_value_setting_connection(self):
         # Tests setting of initial values on connected variables.
@@ -1394,8 +1504,8 @@ class TestCellML2Variable(unittest.TestCase):
         self.assertIs(z.initial_value_variable(), z)
 
         # Check double initial values can't be set
-        z.set_initial_value(v2)
-        z.set_initial_value(myokit.Number(200))
+        z.set_initial_value(v3)
+        z.set_initial_value(myokit.Number(200, myokit.units.V))
         z.set_initial_value(-123)
         self.assertRaisesRegex(
             cellml.CellMLError, 'Unable to change initial value',
@@ -1474,7 +1584,7 @@ class TestCellML2Variable(unittest.TestCase):
         # Only initial value set
         x.set_equation(None)
         self.assertEqual(x.rhs(), y.rhs())
-        self.assertEqual(y.rhs(), myokit.Number(4, myokit.units.V))
+        self.assertEqual(y.rhs(), myokit.Number(4, myokit.units.volt))
 
         # Neither set
         y.set_initial_value(None)
@@ -1885,98 +1995,6 @@ class TestCellML2Methods(unittest.TestCase):
         self.assertFalse(cellml.is_identifier('123'))
         self.assertFalse(cellml.is_identifier('1e3'))
 
-    def test_is_integer_string(self):
-        # Tests is_integer_string().
-
-        self.assertTrue(cellml.is_integer_string('0'))
-        self.assertTrue(cellml.is_integer_string('+0'))
-        self.assertTrue(cellml.is_integer_string('-0'))
-        self.assertTrue(cellml.is_integer_string('3'))
-        self.assertTrue(cellml.is_integer_string('+3'))
-        self.assertTrue(cellml.is_integer_string('-3'))
-        self.assertTrue(cellml.is_integer_string('34269386698604537836794387'))
-
-        self.assertFalse(cellml.is_integer_string(''))
-        self.assertFalse(cellml.is_integer_string('.'))
-        self.assertFalse(cellml.is_integer_string('1.2'))
-        self.assertFalse(cellml.is_integer_string('-1.2'))
-        self.assertFalse(cellml.is_integer_string('1.0'))
-        self.assertFalse(cellml.is_integer_string('1.'))
-        self.assertFalse(cellml.is_integer_string('.0'))
-        self.assertFalse(cellml.is_integer_string('1e3'))
-        self.assertFalse(cellml.is_integer_string('++1'))
-        self.assertFalse(cellml.is_integer_string('+-3'))
-        self.assertFalse(cellml.is_integer_string('--1'))
-        self.assertFalse(cellml.is_integer_string('+'))
-        self.assertFalse(cellml.is_integer_string('-'))
-        self.assertFalse(cellml.is_integer_string('a'))
-        self.assertFalse(cellml.is_integer_string('12C'))
-
-    def test_is_basic_real_number_string(self):
-        # Tests is_basic_real_number_string().
-
-        self.assertTrue(cellml.is_basic_real_number_string('0'))
-        self.assertTrue(cellml.is_basic_real_number_string('+0'))
-        self.assertTrue(cellml.is_basic_real_number_string('-0'))
-        self.assertTrue(cellml.is_basic_real_number_string('3'))
-        self.assertTrue(cellml.is_basic_real_number_string('+3'))
-        self.assertTrue(cellml.is_basic_real_number_string('-3'))
-        self.assertTrue(cellml.is_basic_real_number_string(
-            '3426938669860453783679436474536745674567887'))
-        self.assertTrue(cellml.is_basic_real_number_string(
-            '-.342693866982438645847568457875604537836794387'))
-        self.assertTrue(cellml.is_basic_real_number_string('1.2'))
-        self.assertTrue(cellml.is_basic_real_number_string('-1.2'))
-        self.assertTrue(cellml.is_basic_real_number_string('1.0'))
-        self.assertTrue(cellml.is_basic_real_number_string('1.'))
-        self.assertTrue(cellml.is_basic_real_number_string('.1'))
-
-        self.assertFalse(cellml.is_basic_real_number_string(''))
-        self.assertFalse(cellml.is_basic_real_number_string('.'))
-        self.assertFalse(cellml.is_basic_real_number_string('1e3'))
-        self.assertFalse(cellml.is_basic_real_number_string('++1'))
-        self.assertFalse(cellml.is_basic_real_number_string('+-3'))
-        self.assertFalse(cellml.is_basic_real_number_string('--1'))
-        self.assertFalse(cellml.is_basic_real_number_string('+'))
-        self.assertFalse(cellml.is_basic_real_number_string('-'))
-        self.assertFalse(cellml.is_basic_real_number_string('a'))
-        self.assertFalse(cellml.is_basic_real_number_string('12C'))
-
-    def test_is_real_number_string(self):
-        # Tests is_real_number_string().
-
-        self.assertTrue(cellml.is_real_number_string('0'))
-        self.assertTrue(cellml.is_real_number_string('+0'))
-        self.assertTrue(cellml.is_real_number_string('-0'))
-        self.assertTrue(cellml.is_real_number_string('3'))
-        self.assertTrue(cellml.is_real_number_string('+3'))
-        self.assertTrue(cellml.is_real_number_string('-3'))
-        self.assertTrue(cellml.is_real_number_string(
-            '3426938669860453783679436474536745674567887'))
-        self.assertTrue(cellml.is_real_number_string(
-            '-.342693866982438645847568457875604537836794387'))
-        self.assertTrue(cellml.is_real_number_string('1.2'))
-        self.assertTrue(cellml.is_real_number_string('-1.2'))
-        self.assertTrue(cellml.is_real_number_string('+1.0'))
-        self.assertTrue(cellml.is_real_number_string('+1.'))
-        self.assertTrue(cellml.is_real_number_string('.1'))
-        self.assertTrue(cellml.is_real_number_string('1e3'))
-        self.assertTrue(cellml.is_real_number_string('.1e-3'))
-        self.assertTrue(cellml.is_real_number_string('-1.E0'))
-        self.assertTrue(cellml.is_real_number_string('1E33464636'))
-        self.assertTrue(cellml.is_real_number_string(
-            '1.23000000000000028e+02'))
-
-        self.assertFalse(cellml.is_real_number_string(''))
-        self.assertFalse(cellml.is_real_number_string('.'))
-        self.assertFalse(cellml.is_real_number_string('++1'))
-        self.assertFalse(cellml.is_real_number_string('+-3'))
-        self.assertFalse(cellml.is_real_number_string('--1'))
-        self.assertFalse(cellml.is_real_number_string('+'))
-        self.assertFalse(cellml.is_real_number_string('-'))
-        self.assertFalse(cellml.is_real_number_string('a'))
-        self.assertFalse(cellml.is_real_number_string('12C'))
-
 
 if __name__ == '__main__':
     import warnings

myokit/tests/test_cellml_v2_parser.py

@@ -711,9 +711,39 @@ class TestCellMLParser(unittest.TestCase):
 
         # CellML errors are converted to parsing errors
         x = '<variable name="1" units="volt"/>'
-        x = '<component name="a">' + x + '</component>'
+        x = f'<component name="a">{x}</component>'
         self.assertBad(x, 'valid CellML identifier')
 
+        # Initial values can be numbers or variables
+        m = self.parse(
+            '<component name="c">'
+            '  <variable name="x" units="volt" initial_value="1" />'
+            '  <variable name="y" units="volt" initial_value="x" />'
+            '</component>'
+        )
+        x, y = m['c']['x'], m['c']['y']
+        self.assertEqual(
+            x.initial_value(), myokit.Number(1, myokit.units.volt))
+        self.assertEqual(y.initial_value(), myokit.Name(x))
+
+        # And initial values need delayed handling: Can refer to variable that
+        # has not been parsed yet!
+        m = self.parse(
+            '<component name="c">'
+            '  <variable name="y" units="volt" initial_value="x" />'
+            '  <variable name="x" units="volt" initial_value="1" />'
+            '</component>'
+        )
+        x, y = m['c']['x'], m['c']['y']
+        self.assertEqual(
+            x.initial_value(), myokit.Number(1, myokit.units.volt))
+        self.assertEqual(y.initial_value(), myokit.Name(x))
+
+        # Bad initial values are passed back from the API
+        x = '<variable name="b" units="volt" initial_value="1 + 2" />'
+        x = f'<component name="a">{x}</component>'
+        self.assertBad(x, 'must be a real number or the name of')
+
 
 if __name__ == '__main__':
     import warnings

myokit/tests/test_cellml_v2_writer.py

@@ -112,7 +112,7 @@ class TestCellMLWriter(unittest.TestCase):
         self.assertIs(c.parent(), e)
         self.assertIs(b.parent(), c)
 
-    def test_initial_value_representation(self):
+    def test_initial_values(self):
         # Test the way initial values are represented in generated CellML code
 
         def find(xml):
@@ -142,6 +142,13 @@ class TestCellMLWriter(unittest.TestCase):
         x = find(cellml.write_string(m))
         self.assertEqual(x, '1.23424352342422994')
 
+        # Variable
+        q = c.add_variable('q', 'mole')
+        q.set_initial_value(1)
+        p.set_initial_value('q')
+        x = find(cellml.write_string(m))
+        self.assertEqual(x, 'q')
+
     def test_maths(self):
         # Test maths is written
 

myokit/tests/test_datalog.py

@@ -100,6 +100,23 @@ class DataLogTest(unittest.TestCase):
         self.assertAlmostEqual(1, apds1['duration'][0] / apds2['duration'][0])
         self.assertAlmostEqual(1, apds1['duration'][1] / apds2['duration'][1])
 
+    def test_append_after_access(self):
+        # Test appending to a log after it's been used by matplotlib,
+        # caused problems in older matplotlibs on Python3, but fixed since
+        # Matplotlib 3.6.3 or earlier.
+        import matplotlib
+        matplotlib.use('template')
+        import matplotlib.pyplot as plt
+
+        # Create log, write to it
+        m, p, _ = myokit.load(os.path.join(DIR_DATA, 'lr-1991.mmt'))
+        s = myokit.Simulation(m, p)
+        d = s.run(1)
+        plt.figure()
+        plt.plot(d.time(), d['membrane.V'])
+        d = s.run(1, log=d)
+        plt.close()
+
     def test_clone(self):
         # Test cloning via constructor and clone() method
 

myokit/tests/test_expressions.py

@@ -5,6 +5,7 @@
 # This file is part of Myokit.
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
+import math
 import pickle
 import unittest
 
@@ -708,6 +709,66 @@ class NumberTest(unittest.TestCase):
         self.assertTrue(x.is_number())
         self.assertTrue(x.is_number(0))
 
+    def test_nan_inf(self):
+        # Test nan and inf are represented correctly in code
+
+        # Create from float
+        x = myokit.Number(float('inf'))
+        self.assertTrue(math.isinf(x.eval()))
+        self.assertGreater(x.eval(), 0)
+        self.assertEqual(x.code(), 'infinity')
+
+        # Conversion via Python parsing
+        x = myokit.Number('inf')
+        self.assertTrue(math.isinf(x.eval()))
+        self.assertGreater(x.eval(), 0)
+        self.assertEqual(x.code(), 'infinity')
+
+        # Conversion via Python parsing, but with Myokit syntax
+        x = myokit.Number('infinity')
+        self.assertTrue(math.isinf(x.eval()))
+        self.assertGreater(x.eval(), 0)
+        self.assertEqual(x.code(), 'infinity')
+
+        # Create from float
+        x = myokit.Number(float('-inf'))
+        self.assertTrue(math.isinf(x.eval()))
+        self.assertLess(x.eval(), 0)
+        self.assertEqual(x.code(), '-infinity')
+
+        # Conversion via Python parsing
+        x = myokit.Number('-inf')
+        self.assertTrue(math.isinf(x.eval()))
+        self.assertLess(x.eval(), 0)
+        self.assertEqual(x.code(), '-infinity')
+
+        # Conversion via Python parsing, but with Myokit syntax
+        x = myokit.Number('-infinity')
+        self.assertTrue(math.isinf(x.eval()))
+        self.assertLess(x.eval(), 0)
+        self.assertEqual(x.code(), '-infinity')
+
+        # Create from float
+        x = myokit.Number(float('nan'))
+        self.assertTrue(math.isnan(x.eval()))
+        self.assertEqual(x.code(), 'nan')
+
+        # Conversion via Python parsing
+        x = myokit.Number('nan')
+        self.assertTrue(math.isnan(x.eval()))
+        self.assertEqual(x.code(), 'nan')
+
+        # Conversion via Myokit parsing
+        x = myokit.parse_expression('infinity')
+        self.assertIsInstance(x, myokit.Number)
+        self.assertTrue(math.isinf(x.eval()))
+        self.assertGreater(x.eval(), 0)
+        self.assertEqual(x.code(), 'infinity')
+        x = myokit.parse_expression('nan')
+        self.assertIsInstance(x, myokit.Number)
+        self.assertTrue(math.isnan(x.eval()))
+        self.assertEqual(x.code(), 'nan')
+
     def test_tree_str(self):
         # Test Number.tree_str()
 

myokit/tests/test_formats.py

@@ -235,5 +235,104 @@ class EWriterTest(unittest.TestCase):
             'dada')
 
 
+class FormatsStringTest(unittest.TestCase):
+    """ Test shared string checking functionality """
+
+    def test_is_integer_string(self):
+        # Tests is_integer_string().
+
+        from myokit.formats import is_integer_string as t
+        self.assertTrue(t('0'))
+        self.assertTrue(t('+0'))
+        self.assertTrue(t('-0'))
+        self.assertTrue(t('3'))
+        self.assertTrue(t('+3'))
+        self.assertTrue(t('-3'))
+        self.assertTrue(t('34269386698604537836794387'))
+
+        self.assertFalse(t(''))
+        self.assertFalse(t('.'))
+        self.assertFalse(t('1.2'))
+        self.assertFalse(t('-1.2'))
+        self.assertFalse(t('1.0'))
+        self.assertFalse(t('1.'))
+        self.assertFalse(t('.0'))
+        self.assertFalse(t('1e3'))
+        self.assertFalse(t('++1'))
+        self.assertFalse(t('+-3'))
+        self.assertFalse(t('--1'))
+        self.assertFalse(t('+'))
+        self.assertFalse(t('-'))
+        self.assertFalse(t('a'))
+        self.assertFalse(t('12C'))
+
+        self.assertFalse(t(' -3'))
+        self.assertFalse(t('-3 '))
+        self.assertFalse(t('\t\f123   '))
+        self.assertTrue(t(' -3', True))
+        self.assertTrue(t('-3 ', True))
+        self.assertTrue(t('\t\f123', True))
+
+        # Newline at end: potential pitfall for $
+        self.assertFalse(t('546184\n'))
+        self.assertTrue(t('546184\n', True))
+
+        self.assertFalse(t('', True))
+        self.assertFalse(t('.', True))
+        self.assertFalse(t('-1.2', True))
+        self.assertFalse(t('++1', True))
+
+    def test_is_real_number_string(self):
+        # Tests is_real_number_string().
+
+        from myokit.formats import is_real_number_string as t
+        self.assertTrue(t('0'))
+        self.assertTrue(t('+0'))
+        self.assertTrue(t('-0'))
+        self.assertTrue(t('3'))
+        self.assertTrue(t('+3'))
+        self.assertTrue(t('-3'))
+        self.assertTrue(t(
+            '3426938669860453783679436474536745674567887'))
+        self.assertTrue(t(
+            '-.342693866982438645847568457875604537836794387'))
+        self.assertTrue(t('1.2'))
+        self.assertTrue(t('-1.2'))
+        self.assertTrue(t('+1.0'))
+        self.assertTrue(t('+1.'))
+        self.assertTrue(t('.1'))
+        self.assertTrue(t('1e3'))
+        self.assertTrue(t('.1e-3'))
+        self.assertTrue(t('-1.E0'))
+        self.assertTrue(t('1E33464636'))
+        self.assertTrue(t('1.23000000000000028e+02'))
+
+        self.assertFalse(t(''))
+        self.assertFalse(t('.'))
+        self.assertFalse(t('++1'))
+        self.assertFalse(t('+-3'))
+        self.assertFalse(t('--1'))
+        self.assertFalse(t('+'))
+        self.assertFalse(t('-'))
+        self.assertFalse(t('a'))
+        self.assertFalse(t('12C'))
+
+        self.assertFalse(t(' 1'))
+        self.assertFalse(t('1 '))
+        self.assertFalse(t('\t\f1'))
+        self.assertTrue(t(' 1', True))
+        self.assertTrue(t('1 ', True))
+        self.assertTrue(t('\t\f1', True))
+
+        # Newline at end: potential pitfall for $
+        self.assertFalse(t('+3\n'))
+        self.assertTrue(t('+3\n', True))
+
+        self.assertFalse(t('', True))
+        self.assertFalse(t('.', True))
+        self.assertFalse(t('++1', True))
+        self.assertFalse(t('+', True))
+
+
 if __name__ == '__main__':
     unittest.main()