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

myokit/tests/test_formats_latex.py

@@ -0,0 +1,211 @@
+#!/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.latex
+
+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,
+)
+
+import myokit.tests
+
+
+class LatexExpressionWriterTest(myokit.tests.ExpressionWriterTestCase):
+    """
+    Test conversion of expressions to Python.
+    This is used by pyfunc(), although that's usually done with the
+    NumPyExpressionWriter instead.
+    Numerical tests are provided.
+    """
+    _name = 'latex'
+    _target = myokit.formats.latex.LatexExpressionWriter
+    _update_lhs_function = False
+
+    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'), r'13.0 \text{mV}')
+        self.eq(Number(2, 'A/F'), r'2.0 \text{A/F}')
+        self.eq(Number(7, myokit.units.dimensionless), '7.0')
+
+    def test_name(self):
+        self.eq(self.a, r'\text{a}')
+        m = myokit.Model()
+        c = m.add_component('c')
+        v = c.add_variable('under_score', rhs=3)
+        t = c.add_variable('time', rhs=0, binding='time')
+        m.validate()
+        self.eq(myokit.Name(v), r'\text{under\_score}')
+
+        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), r'\frac{d\text{a}}{d\text{t}}')
+
+        w = self._target()
+        w.set_time_variable_name('timmy')
+        self.assertEqual(w.ex(myokit.Derivative(self.a)),
+                         r'\frac{d\text{a}}{d\text{timmy}}')
+        w.set_time_variable_name('Bob')
+        self.assertEqual(w.ex(myokit.Derivative(self.a)),
+                         r'\frac{d\text{a}}{d\text{Bob}}')
+
+    def test_partial_derivative(self):
+        self.eq(myokit.PartialDerivative(self.a, self.b),
+                r'\frac{\partial\text{a}}{\partial\text{b}}')
+
+    def test_initial_value(self):
+        self.eq(myokit.InitialValue(self.a), r'\text{a}(\text{t} = 0)')
+
+    def test_prefix_plus(self):
+        # Test with numbers
+        p = Number(11, 'mV')
+        self.eq(PrefixPlus(p), r'+11.0 \text{mV}')
+        p = Number(3)
+        self.eq(PrefixPlus(PrefixPlus(p)), '++3.0')
+        self.eq(PrefixPlus(Number('+1')), '+1.0')
+
+        # Test with operators of precedence SUM, PRODUCT, POWER
+        a, b, c = self.abc
+        self.eq(PrefixPlus(Plus(a, b)), r'+\left(\text{a}+\text{b}\right)')
+        self.eq(Divide(PrefixPlus(Plus(a, b)), c),
+                r'\frac{+\left(\text{a}+\text{b}\right)}{\text{c}}')
+        self.eq(Power(PrefixPlus(b), a),
+                r'\left(+\text{b}\right)^\text{a}')
+
+    def test_prefix_minus(self):
+        # Test with numbers
+        p = Number(3, 'uA')
+        self.eq(PrefixMinus(p), r'-3.0 \text{uA}')
+        p = Number(2)
+        self.eq(PrefixMinus(PrefixMinus(p)), '--2.0')
+        self.eq(PrefixMinus(Number('-1')), '--1.0')
+
+        # Test with operators of precedence SUM, PRODUCT, POWER
+        a, b, c = self.abc
+        self.eq(PrefixMinus(Plus(a, b)), r'-\left(\text{a}+\text{b}\right)')
+        self.eq(Divide(PrefixMinus(Plus(a, b)), c),
+                r'\frac{-\left(\text{a}+\text{b}\right)}{\text{c}}')
+        self.eq(Power(PrefixMinus(b), a),
+                r'\left(-\text{b}\right)^\text{a}')
+
+    def test_plus_minus(self):
+        a, b, c = self.abc
+        ta, tb, tc = r'\text{a}', r'\text{b}', r'\text{c}'
+        self.eq(Plus(a, b), f'{ta}+{tb}')
+        self.eq(Plus(Plus(a, b), c), f'{ta}+{tb}+{tc}')
+        self.eq(Plus(a, Plus(b, c)), rf'{ta}+\left({tb}+{tc}\right)')
+
+        self.eq(Minus(a, b), f'{ta}-{tb}')
+        self.eq(Minus(Minus(a, b), c), f'{ta}-{tb}-{tc}')
+        self.eq(Minus(a, Minus(b, c)), rf'{ta}-\left({tb}-{tc}\right)')
+
+        self.eq(Minus(a, b), f'{ta}-{tb}')
+        self.eq(Plus(Minus(a, b), c), f'{ta}-{tb}+{tc}')
+        self.eq(Minus(a, Plus(b, c)), rf'{ta}-\left({tb}+{tc}\right)')
+        self.eq(Minus(Plus(a, b), c), f'{ta}+{tb}-{tc}')
+        self.eq(Minus(a, Plus(b, c)), rf'{ta}-\left({tb}+{tc}\right)')
+
+    def test_multiply_divide(self):
+        a, b, c = self.abc
+        ta, tb, tc = r'\text{a}', r'\text{b}', r'\text{c}'
+        l, r = r'\left(', r'\right)'
+        self.eq(Multiply(a, b), rf'{ta}\cdot{tb}')
+        self.eq(Multiply(Multiply(a, b), c), rf'{ta}\cdot{tb}\cdot{tc}')
+        self.eq(Multiply(a, Multiply(b, c)), rf'{ta}\cdot{l}{tb}\cdot{tc}{r}')
+        self.eq(Divide(a, b), r'\frac{\text{a}}{\text{b}}')
+        self.eq(Divide(Divide(a, b), c),
+                r'\frac{\frac{\text{a}}{\text{b}}}{\text{c}}')
+        self.eq(Divide(a, Divide(b, c)),
+                r'\frac{\text{a}}{\frac{\text{b}}{\text{c}}}')
+        self.eq(Divide(Divide(a, b), c),
+                r'\frac{\frac{\text{a}}{\text{b}}}{\text{c}}')
+        self.eq(Divide(Multiply(a, b), c),
+                r'\frac{\text{a}\cdot\text{b}}{\text{c}}')
+
+        self.eq(Multiply(Minus(a, b), c), rf'{l}{ta}-{tb}{r}\cdot{tc}')
+        self.eq(Multiply(a, Plus(b, c)), rf'{ta}\cdot{l}{tb}+{tc}{r}')
+        self.eq(Plus(a, Multiply(b, c)), rf'{ta}+{tb}\cdot{tc}')
+
+    def test_remainder_quotient(self):
+        a, b = self.ab
+        self.eq(Remainder(a, b), r'\text{a}\bmod\text{b}')
+        self.eq(Quotient(a, b),
+                r'\left\lfloor\frac{\text{a}}{\text{b}}\right\rfloor')
+
+    def test_power(self):
+        a, b, c = self.abc
+        ta, tb, tc = r'\text{a}', r'\text{b}', r'\text{c}'
+        l, r = r'\left(', r'\right)'
+        p, q = '{', '}'
+        self.eq(Power(a, b), f'{ta}^{tb}')
+        self.eq(Power(Power(a, b), c), f'{l}{ta}^{tb}{r}^{tc}')
+        self.eq(Power(a, Power(b, c)), f'{ta}^{p}{tb}^{tc}{q}')
+        self.eq(Power(Plus(a, b), c), f'{l}{ta}+{tb}{r}^{tc}')
+        self.eq(Power(a, Minus(b, c)), f'{ta}^{p}{tb}-{tc}{q}')
+
+    def test_functions(self):
+        a, b = self.ab
+
+        self.eq(Sqrt(a), r'\sqrt{\text{a}}')
+        self.eq(Exp(a), r'\exp\left(\text{a}\right)')
+        self.eq(Log(a), r'\log\left(\text{a}\right)')
+        self.eq(Log(a, b), r'\log_{\text{b}}\left(\text{a}\right)')
+        self.eq(Log10(a), r'\log_{10}\left(\text{a}\right)')
+        self.eq(Sin(a), r'\sin\left(\text{a}\right)')
+        self.eq(Cos(a), r'\cos\left(\text{a}\right)')
+        self.eq(Tan(a), r'\tan\left(\text{a}\right)')
+        self.eq(ASin(a), r'\arcsin\left(\text{a}\right)')
+        self.eq(ACos(a), r'\arccos\left(\text{a}\right)')
+        self.eq(ATan(a), r'\arctan\left(\text{a}\right)')
+        self.eq(Floor(a), r'\left\lfloor{\text{a}}\right\rfloor')
+        self.eq(Ceil(a), r'\left\lceil{\text{a}}\right\rceil')
+        self.eq(Abs(a), r'\lvert{\text{a}}\rvert')
+
+    def test_conditions(self):
+        a, b, c, d = self.abcd
+
+        self.eq(And(a, b), r'\left(\text{a}\and\text{b}\right)')
+        self.eq(Or(d, c), r'\left(\text{d}\or\text{c}\right)')
+        self.eq(Not(c), r'\left(\not\text{c}\right)')
+
+        self.eq(Equal(a, b), r'\left(\text{a}=\text{b}\right)')
+        self.eq(NotEqual(a, b), r'\left(\text{a}\neq\text{b}\right)')
+        self.eq(More(b, a), r'\left(\text{b}>\text{a}\right)')
+        self.eq(Less(d, c), r'\left(\text{d}<\text{c}\right)')
+        self.eq(MoreEqual(c, a), r'\left(\text{c}\geq\text{a}\right)')
+        self.eq(LessEqual(b, d), r'\left(\text{b}\leq\text{d}\right)')
+
+        self.eq(And(Equal(a, b), NotEqual(c, d)),
+                r'\left(\left(\text{a}=\text{b}\right)\and'
+                r'\left(\text{c}\neq\text{d}\right)\right)')
+        self.eq(Not(Equal(d, d)),
+                r'\left(\not\left(\text{d}=\text{d}\right)\right)')
+        self.eq(Equal(Equal(Number(0), Number(0)), Number(0)),
+                r'\left(\left(0.0=0.0\right)=0.0\right)')
+
+    def test_conditionals(self):
+
+        a, b, c, d = self.abcd
+        self.eq(myokit.If(a, b, c),
+                r'\text{if}\left(\text{a},\text{b},\text{c}\right)')
+        self.eq(myokit.Piecewise(a, b, c, d, Number(1)), r'\text{piecewise}'
+                r'\left(\text{a},\text{b},\text{c},\text{d},1.0\right)')
+
+
+if __name__ == '__main__':
+    unittest.main()

myokit/tests/test_formats_mathml_content.py

@@ -82,6 +82,10 @@ class ContentMathMLParserTest(unittest.TestCase):
         e = myokit.PrefixPlus(myokit.Number(1))
         x = '<apply><plus/><cn>1.0</cn></apply>'
         self.assertEqual(self.p(x), e)
+        e = myokit.PrefixPlus(myokit.Plus(myokit.Number(3), myokit.Number(4)))
+        x = ('<apply><plus/><apply><plus /><cn>3.0</cn><cn>4.0</cn></apply>'
+             '</apply>')
+        self.assertEqual(self.p(x), e)
 
         # Prefix minus
         e = myokit.PrefixMinus(myokit.Number(1))
@@ -358,9 +362,18 @@ class ContentMathMLParserTest(unittest.TestCase):
         # 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.
 

myokit/tests/test_formats_mathml_presentation.py

@@ -22,6 +22,7 @@ class PresentationMathMLTest(unittest.TestCase):
         model = myokit.Model()
         component = model.add_component('c')
         cls.avar = component.add_variable('a')
+        cls.bvar = component.add_variable('b')
 
         cls.w = mathml.MathMLExpressionWriter()
         cls.w.set_mode(presentation=True)
@@ -46,33 +47,40 @@ class PresentationMathMLTest(unittest.TestCase):
 
         # Plus
         x = myokit.Plus(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>+</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>+</mo>{cb}</mrow>')
 
         # Minus
         x = myokit.Minus(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>-</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>-</mo>{cb}</mrow>')
 
         # Multiply
         x = myokit.Multiply(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>*</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>*</mo>{cb}</mrow>')
 
         # Divide
         x = myokit.Divide(a, b)
-        self.assertWrite(x, '<mfrac>' + ca + cb + '</mfrac>')
+        self.assertWrite(x, f'<mfrac>{ca + cb}</mfrac>')
 
     def test_arithmetic_unary(self):
         # Tests writing prefix operators
 
+        a = myokit.Name(self.avar)
         b = myokit.Number('12', 'pF')
+        ca = '<mi>c.a</mi>'
         cb = '<mn>12.0</mn>'
 
         # Prefix plus
         x = myokit.PrefixPlus(b)
-        self.assertWrite(x, '<mrow><mo>+</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow><mo>+</mo>{cb}</mrow>')
+        x = myokit.Divide(myokit.PrefixPlus(myokit.Plus(a, b)), a)
+        self.assertWrite(
+            x,
+            f'<mfrac><mrow><mo>+</mo><mo>(</mo><mrow>{ca}<mo>+</mo>{cb}</mrow>'
+            f'<mo>)</mo></mrow>{ca}</mfrac>')
 
         # Prefix minus
         x = myokit.PrefixMinus(b)
-        self.assertWrite(x, '<mrow><mo>-</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow><mo>-</mo>{cb}</mrow>')
 
     def test_conditionals(self):
         # Tests if and piecewise writing
@@ -94,8 +102,8 @@ class PresentationMathMLTest(unittest.TestCase):
         self.assertWrite(
             x,
             '<piecewise>'
-            '<piece>' + ca + c1 + '</piece>'
-            '<otherwise>' + cb + '</otherwise>'
+            f'<piece>{ca + c1}</piece>'
+            f'<otherwise>{cb}</otherwise>'
             '</piecewise>'
         )
         # Piecewise
@@ -103,9 +111,9 @@ class PresentationMathMLTest(unittest.TestCase):
         self.assertWrite(
             x,
             '<piecewise>'
-            '<piece>' + ca + c1 + '</piece>'
-            '<piece>' + cb + c2 + '</piece>'
-            '<otherwise>' + cc + '</otherwise>'
+            f'<piece>{ca + c1}</piece>'
+            f'<piece>{cb + c2}</piece>'
+            f'<otherwise>{cc}</otherwise>'
             '</piecewise>'
         )
 
@@ -119,63 +127,69 @@ class PresentationMathMLTest(unittest.TestCase):
         # Tests writing basic functions
 
         a = myokit.Name(self.avar)
-        b = myokit.Number('12', 'pF')
+        b = myokit.Name(self.bvar)
+        c = myokit.Number('12', 'pF')
         ca = '<mi>c.a</mi>'
-        cb = '<mn>12.0</mn>'
+        cb = '<mi>c.b</mi>'
+        cc = '<mn>12.0</mn>'
 
         # Power
         x = myokit.Power(a, b)
-        self.assertWrite(x, '<msup>' + ca + cb + '</msup>')
+        self.assertWrite(x, f'<msup>{ca}{cb}</msup>')
+        x = myokit.Power(myokit.Power(a, b), c)
+        self.assertWrite(x, f'<msup><msup>{ca}{cb}</msup>{cc}</msup>')
+        x = myokit.Power(a, myokit.Power(b, c))
+        self.assertWrite(x, f'<msup>{ca}<msup>{cb}{cc}</msup></msup>')
 
         # Sqrt
         x = myokit.Sqrt(b)
         self.assertWrite(
-            x, '<mrow><mi>root</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>root</mi><mfenced>{cb}</mfenced></mrow>')
 
         # Exp
         x = myokit.Exp(a)
-        self.assertWrite(x, '<msup><mi>e</mi>' + ca + '</msup>')
+        self.assertWrite(x, f'<msup><mi>e</mi>{ca}</msup>')
 
         # Log(a)
         x = myokit.Log(b)
         self.assertWrite(
-            x, '<mrow><mi>ln</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>ln</mi><mfenced>{cb}</mfenced></mrow>')
 
         # Log(a, b)
         x = myokit.Log(a, b)
         self.assertWrite(
             x,
-            '<mrow><msub><mi>log</mi>' + cb + '</msub>'
-            '<mfenced>' + ca + '</mfenced></mrow>'
+            f'<mrow><msub><mi>log</mi>{cb}</msub>'
+            f'<mfenced>{ca}</mfenced></mrow>'
         )
 
         # Log10
         x = myokit.Log10(b)
         self.assertWrite(
-            x, '<mrow><mi>log</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>log</mi><mfenced>{cb}</mfenced></mrow>')
 
         # Floor
         x = myokit.Floor(b)
         self.assertWrite(
-            x, '<mrow><mi>floor</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>floor</mi><mfenced>{cb}</mfenced></mrow>')
 
         # Ceil
         x = myokit.Ceil(b)
         self.assertWrite(
-            x, '<mrow><mi>ceiling</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>ceiling</mi><mfenced>{cb}</mfenced></mrow>')
 
         # Abs
         x = myokit.Abs(b)
         self.assertWrite(
-            x, '<mrow><mi>abs</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>abs</mi><mfenced>{cb}</mfenced></mrow>')
 
         # Quotient
         x = myokit.Quotient(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>//</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>//</mo>{cb}</mrow>')
 
         # Remainder
         x = myokit.Remainder(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>%</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>%</mo>{cb}</mrow>')
 
     def test_inequalities(self):
         # Test writing (in)equalities
@@ -187,31 +201,29 @@ class PresentationMathMLTest(unittest.TestCase):
 
         # Equal
         x = myokit.Equal(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>==</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>==</mo>{cb}</mrow>')
 
         # NotEqual
         x = myokit.NotEqual(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>!=</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>!=</mo>{cb}</mrow>')
 
         # More
         x = myokit.More(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>&gt;</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>&gt;</mo>{cb}</mrow>')
 
         # Less
         x = myokit.Less(a, b)
-        self.assertWrite(x, '<mrow>' + ca + '<mo>&lt;</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>&lt;</mo>{cb}</mrow>')
 
         # MoreEqual
         # Named version &ge; is not output, shows decimal code instead
         x = myokit.MoreEqual(a, b)
-        self.assertWrite(
-            x, '<mrow>' + ca + '<mo>&#8805;</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>&#8805;</mo>{cb}</mrow>')
 
         # LessEqual
         # Named version &le; is not output, shows decimal code instead
         x = myokit.LessEqual(a, b)
-        self.assertWrite(
-            x, '<mrow>' + ca + '<mo>&#8804;</mo>' + cb + '</mrow>')
+        self.assertWrite(x, f'<mrow>{ca}<mo>&#8804;</mo>{cb}</mrow>')
 
     def test_logic_operators(self):
         # Tests writing logic operators
@@ -224,15 +236,15 @@ class PresentationMathMLTest(unittest.TestCase):
         # Not
         x = myokit.Not(cond1)
         self.assertWrite(
-            x, '<mrow><mo>(</mo><mo>not</mo>' + c1 + '<mo>)</mo></mrow>')
+            x, f'<mrow><mo>not</mo><mo>(</mo>{c1}<mo>)</mo></mrow>')
 
         # And
         x = myokit.And(cond1, cond2)
-        self.assertWrite(x, '<mrow>' + c1 + '<mo>and</mo>' + c2 + '</mrow>')
+        self.assertWrite(x, f'<mrow>{c1}<mo>and</mo>{c2}</mrow>')
 
         # Or
         x = myokit.Or(cond1, cond2)
-        self.assertWrite(x, '<mrow>' + c1 + '<mo>or</mo>' + c2 + '</mrow>')
+        self.assertWrite(x, f'<mrow>{c1}<mo>or</mo>{c2}</mrow>')
 
     def test_name_and_numbers(self):
         # Test name and number writing
@@ -259,32 +271,32 @@ class PresentationMathMLTest(unittest.TestCase):
         # Sin
         x = myokit.Sin(b)
         self.assertWrite(
-            x, '<mrow><mi>sin</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>sin</mi><mfenced>{cb}</mfenced></mrow>')
 
         # Cos
         x = myokit.Cos(b)
         self.assertWrite(
-            x, '<mrow><mi>cos</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>cos</mi><mfenced>{cb}</mfenced></mrow>')
 
         # Tan
         x = myokit.Tan(b)
         self.assertWrite(
-            x, '<mrow><mi>tan</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>tan</mi><mfenced>{cb}</mfenced></mrow>')
 
         # ASin
         x = myokit.ASin(b)
         self.assertWrite(
-            x, '<mrow><mi>arcsin</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>arcsin</mi><mfenced>{cb}</mfenced></mrow>')
 
         # ACos
         x = myokit.ACos(b)
         self.assertWrite(
-            x, '<mrow><mi>arccos</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>arccos</mi><mfenced>{cb}</mfenced></mrow>')
 
         # ATan
         x = myokit.ATan(b)
         self.assertWrite(
-            x, '<mrow><mi>arctan</mi><mfenced>' + cb + '</mfenced></mrow>')
+            x, f'<mrow><mi>arctan</mi><mfenced>{cb}</mfenced></mrow>')
 
     def test_unknown_expression(self):
         # Test without a Myokit expression