def equal(self):
"""
Test of __eq__ operators
"""
a1 = myokit.Number(4)
a2 = myokit.Number(5)
self.assertEqual(a1, a1)
self.assertEqual(a1, myokit.Number(4))
self.assertEqual(a1, myokit.Number(4.0))
self.assertNotEqual(a1, a2)
b1 = myokit.Name('test')
b2 = myokit.Name('tost')
self.assertEqual(b1, b1)
self.assertNotEqual(b1, b2)
c1 = myokit.PrefixPlus(a1)
c2 = myokit.PrefixPlus(a1)
self.assertEqual(c1, c1)
self.assertEqual(c1, c2)
c2 = myokit.PrefixPlus(a2)
self.assertNotEqual(c1, c2)
d1 = myokit.Plus(a1, a2)
d2 = myokit.Plus(a1, a2)
self.assertEqual(d1, d1)
self.assertEqual(d1, d2)
d2 = myokit.Plus(a2, a1)
self.assertNotEqual(d2, d1)
e1 = myokit.Sqrt(a1)
e2 = myokit.Sqrt(a1)
self.assertEqual(e1, e1)
self.assertEqual(e1, e2)
e2 = myokit.Sqrt(a2)
self.assertNotEqual(e1, e2)
def test_arithmetic(self):
# Test basic arithmetic
a = myokit.Name(self.avar)
b = myokit.Number('12', 'pF')
ca = '<ci>a</ci>'
cb = ('<cn cellml:units="picofarad">12.0</cn>')
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertWrite(x, '<apply><plus/>' + cb + '</apply>')
# Prefix minus
x = myokit.PrefixMinus(b)
self.assertWrite(x, '<apply><minus/>' + cb + '</apply>')
# Plus
x = myokit.Plus(a, b)
self.assertWrite(x, '<apply><plus/>' + ca + cb + '</apply>')
# Minus
x = myokit.Minus(a, b)
self.assertWrite(x, '<apply><minus/>' + ca + cb + '</apply>')
# Multiply
x = myokit.Multiply(a, b)
self.assertWrite(x, '<apply><times/>' + ca + cb + '</apply>')
# Divide
x = myokit.Divide(a, b)
self.assertWrite(x, '<apply><divide/>' + ca + cb + '</apply>')
def test_arithmetic_unary(self):
# Tests writing prefix operators
# Prefix plus
m = myokit.PrefixPlus(myokit.Number(1))
x = '<apply><plus/><cn>1.0</cn></apply>'
self.assertWrite(m, x)
# Prefix minus
m = myokit.PrefixMinus(myokit.Number(1))
x = '<apply><minus/><cn>1.0</cn></apply>'
self.assertWrite(m, x)
def test_arithmetic_unary(self):
# Tests parsing basic arithmetic operators
# Prefix plus
e = myokit.PrefixPlus(myokit.Number(1))
x = '<apply><plus/><cn>1.0</cn></apply>'
self.assertEqual(self.p(x), e)
# Prefix minus
e = myokit.PrefixMinus(myokit.Number(1))
x = '<apply><minus/><cn>1.0</cn></apply>'
self.assertEqual(self.p(x), e)
def test_arithmetic_unary(self):
# Tests writing prefix operators
b = myokit.Number('12', 'pF')
cb = '<mn>12.0</mn>'
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertWrite(x, '<mrow><mo>+</mo>' + cb + '</mrow>')
# Prefix minus
x = myokit.PrefixMinus(b)
self.assertWrite(x, '<mrow><mo>-</mo>' + cb + '</mrow>')
def test_all(self):
w = myokit.formats.python.PythonExpressionWriter()
model = myokit.Model()
component = model.add_component('c')
avar = component.add_variable('a')
# Name
a = myokit.Name(avar)
self.assertEqual(w.ex(a), 'c.a')
# Number with unit
b = myokit.Number('12', 'pF')
self.assertEqual(w.ex(b), '12.0')
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertEqual(w.ex(x), '12.0')
# Prefix minus
x = myokit.PrefixMinus(b)
self.assertEqual(w.ex(x), '(-12.0)')
# Plus
x = myokit.Plus(a, b)
self.assertEqual(w.ex(x), 'c.a + 12.0')
# Minus
x = myokit.Minus(a, b)
self.assertEqual(w.ex(x), 'c.a - 12.0')
# Multiply
x = myokit.Multiply(a, b)
self.assertEqual(w.ex(x), 'c.a * 12.0')
# Divide
x = myokit.Divide(a, b)
self.assertEqual(w.ex(x), 'c.a / 12.0')
# Quotient
x = myokit.Quotient(a, b)
self.assertEqual(w.ex(x), 'c.a // 12.0')
# Remainder
x = myokit.Remainder(a, b)
self.assertEqual(w.ex(x), 'c.a % 12.0')
# Power
x = myokit.Power(a, b)
self.assertEqual(w.ex(x), 'c.a ** 12.0')
# Sqrt
x = myokit.Sqrt(b)
self.assertEqual(w.ex(x), 'math.sqrt(12.0)')
# Exp
x = myokit.Exp(a)
self.assertEqual(w.ex(x), 'math.exp(c.a)')
# Log(a)
x = myokit.Log(b)
self.assertEqual(w.ex(x), 'math.log(12.0)')
# Log(a, b)
x = myokit.Log(a, b)
self.assertEqual(w.ex(x), 'math.log(c.a, 12.0)')
# Log10
x = myokit.Log10(b)
self.assertEqual(w.ex(x), 'math.log10(12.0)')
# Sin
x = myokit.Sin(b)
self.assertEqual(w.ex(x), 'math.sin(12.0)')
# Cos
x = myokit.Cos(b)
self.assertEqual(w.ex(x), 'math.cos(12.0)')
# Tan
x = myokit.Tan(b)
self.assertEqual(w.ex(x), 'math.tan(12.0)')
# ASin
x = myokit.ASin(b)
self.assertEqual(w.ex(x), 'math.asin(12.0)')
# ACos
x = myokit.ACos(b)
self.assertEqual(w.ex(x), 'math.acos(12.0)')
# ATan
x = myokit.ATan(b)
self.assertEqual(w.ex(x), 'math.atan(12.0)')
# Floor
x = myokit.Floor(b)
self.assertEqual(w.ex(x), 'math.floor(12.0)')
# Ceil
x = myokit.Ceil(b)
self.assertEqual(w.ex(x), 'math.ceil(12.0)')
# Abs
x = myokit.Abs(b)
self.assertEqual(w.ex(x), 'abs(12.0)')
# Equal
x = myokit.Equal(a, b)
self.assertEqual(w.ex(x), '(c.a == 12.0)')
# NotEqual
x = myokit.NotEqual(a, b)
self.assertEqual(w.ex(x), '(c.a != 12.0)')
# More
x = myokit.More(a, b)
self.assertEqual(w.ex(x), '(c.a > 12.0)')
# Less
x = myokit.Less(a, b)
self.assertEqual(w.ex(x), '(c.a < 12.0)')
# MoreEqual
x = myokit.MoreEqual(a, b)
self.assertEqual(w.ex(x), '(c.a >= 12.0)')
# LessEqual
x = myokit.LessEqual(a, b)
self.assertEqual(w.ex(x), '(c.a <= 12.0)')
# Not
cond1 = myokit.parse_expression('5 > 3')
cond2 = myokit.parse_expression('2 < 1')
x = myokit.Not(cond1)
self.assertEqual(w.ex(x), 'not ((5.0 > 3.0))')
# And
x = myokit.And(cond1, cond2)
self.assertEqual(w.ex(x), '((5.0 > 3.0) and (2.0 < 1.0))')
# Or
x = myokit.Or(cond1, cond2)
self.assertEqual(w.ex(x), '((5.0 > 3.0) or (2.0 < 1.0))')
# If
x = myokit.If(cond1, a, b)
self.assertEqual(w.ex(x), '(c.a if (5.0 > 3.0) else 12.0)')
# Piecewise
c = myokit.Number(1)
x = myokit.Piecewise(cond1, a, cond2, b, c)
self.assertEqual(
w.ex(x),
'(c.a if (5.0 > 3.0) else (12.0 if (2.0 < 1.0) else 1.0))')
# Test fetching using ewriter method
w = myokit.formats.ewriter('python')
self.assertIsInstance(w, myokit.formats.python.PythonExpressionWriter)
# Test lhs method
w.set_lhs_function(lambda x: 'sheep')
self.assertEqual(w.ex(a), 'sheep')
# Test without a Myokit expression
self.assertRaisesRegex(ValueError, 'Unknown expression type', w.ex, 7)
def test_all(self):
w = myokit.formats.matlab.MatlabExpressionWriter()
model = myokit.Model()
component = model.add_component('c')
avar = component.add_variable('a')
# Name
a = myokit.Name(avar)
self.assertEqual(w.ex(a), 'c.a')
# Number with unit
b = myokit.Number('12', 'pF')
self.assertEqual(w.ex(b), '12.0')
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertEqual(w.ex(x), '12.0')
# Prefix minus
x = myokit.PrefixMinus(b)
self.assertEqual(w.ex(x), '(-12.0)')
# Plus
x = myokit.Plus(a, b)
self.assertEqual(w.ex(x), 'c.a + 12.0')
# Minus
x = myokit.Minus(a, b)
self.assertEqual(w.ex(x), 'c.a - 12.0')
# Multiply
x = myokit.Multiply(a, b)
self.assertEqual(w.ex(x), 'c.a * 12.0')
# Divide
x = myokit.Divide(a, b)
self.assertEqual(w.ex(x), 'c.a / 12.0')
# Quotient
x = myokit.Quotient(a, b)
self.assertEqual(w.ex(x), 'floor(c.a / 12.0)')
# Remainder
x = myokit.Remainder(a, b)
self.assertEqual(w.ex(x), 'mod(c.a, 12.0)')
# Power
x = myokit.Power(a, b)
self.assertEqual(w.ex(x), 'c.a ^ 12.0')
# Sqrt
x = myokit.Sqrt(b)
self.assertEqual(w.ex(x), 'sqrt(12.0)')
# Exp
x = myokit.Exp(a)
self.assertEqual(w.ex(x), 'exp(c.a)')
# Log(a)
x = myokit.Log(b)
self.assertEqual(w.ex(x), 'log(12.0)')
# Log(a, b)
x = myokit.Log(a, b)
self.assertEqual(w.ex(x), '(log(c.a) / log(12.0))')
# Log10
x = myokit.Log10(b)
self.assertEqual(w.ex(x), 'log10(12.0)')
# Sin
x = myokit.Sin(b)
self.assertEqual(w.ex(x), 'sin(12.0)')
# Cos
x = myokit.Cos(b)
self.assertEqual(w.ex(x), 'cos(12.0)')
# Tan
x = myokit.Tan(b)
self.assertEqual(w.ex(x), 'tan(12.0)')
# ASin
x = myokit.ASin(b)
self.assertEqual(w.ex(x), 'asin(12.0)')
# ACos
x = myokit.ACos(b)
self.assertEqual(w.ex(x), 'acos(12.0)')
# ATan
x = myokit.ATan(b)
self.assertEqual(w.ex(x), 'atan(12.0)')
# Floor
x = myokit.Floor(b)
self.assertEqual(w.ex(x), 'floor(12.0)')
# Ceil
x = myokit.Ceil(b)
self.assertEqual(w.ex(x), 'ceil(12.0)')
# Abs
x = myokit.Abs(b)
self.assertEqual(w.ex(x), 'abs(12.0)')
# Equal
x = myokit.Equal(a, b)
self.assertEqual(w.ex(x), '(c.a == 12.0)')
# NotEqual
x = myokit.NotEqual(a, b)
self.assertEqual(w.ex(x), '(c.a != 12.0)')
# More
x = myokit.More(a, b)
self.assertEqual(w.ex(x), '(c.a > 12.0)')
# Less
x = myokit.Less(a, b)
self.assertEqual(w.ex(x), '(c.a < 12.0)')
# MoreEqual
x = myokit.MoreEqual(a, b)
self.assertEqual(w.ex(x), '(c.a >= 12.0)')
# LessEqual
x = myokit.LessEqual(a, b)
self.assertEqual(w.ex(x), '(c.a <= 12.0)')
# Not
cond1 = myokit.parse_expression('5 > 3')
cond2 = myokit.parse_expression('2 < 1')
x = myokit.Not(cond1)
self.assertEqual(w.ex(x), '!((5.0 > 3.0))')
# And
x = myokit.And(cond1, cond2)
self.assertEqual(w.ex(x), '((5.0 > 3.0) && (2.0 < 1.0))')
# Or
x = myokit.Or(cond1, cond2)
self.assertEqual(w.ex(x), '((5.0 > 3.0) || (2.0 < 1.0))')
# If (custom function)
x = myokit.If(cond1, a, b)
self.assertEqual(w.ex(x), 'ifthenelse((5.0 > 3.0), c.a, 12.0)')
# Piecewise
c = myokit.Number(1)
x = myokit.Piecewise(cond1, a, cond2, b, c)
self.assertEqual(
w.ex(x),
'ifthenelse((5.0 > 3.0), c.a, ifthenelse((2.0 < 1.0), 12.0, 1.0))')
# Test fetching using ewriter method
w = myokit.formats.ewriter('matlab')
self.assertIsInstance(w, myokit.formats.matlab.MatlabExpressionWriter)
# Test without a Myokit expression
self.assertRaisesRegex(ValueError, 'Unknown expression type', w.ex, 7)
def test_all(self):
w = myokit.formats.latex.LatexExpressionWriter()
model = myokit.Model()
component = model.add_component('c')
avar = component.add_variable('a')
# Model needs to be validated --> sets unames
avar.set_rhs(12)
avar.set_binding('time')
model.validate()
# Name
a = myokit.Name(avar)
self.assertEqual(w.ex(a), '\\text{a}')
# Number with unit
b = myokit.Number('12', 'pF')
self.assertEqual(w.ex(b), '12.0')
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertEqual(w.ex(x), '12.0')
# Prefix minus
x = myokit.PrefixMinus(b)
self.assertEqual(w.ex(x), '\\left(-12.0\\right)')
# Prefix minus with bracket
x = myokit.PrefixMinus(myokit.Plus(a, b))
self.assertEqual(w.ex(x),
'\\left(-\\left(\\text{a}+12.0\\right)\\right)')
# Plus
x = myokit.Plus(a, b)
self.assertEqual(w.ex(x), '\\text{a}+12.0')
# Minus
x = myokit.Minus(a, b)
self.assertEqual(w.ex(x), '\\text{a}-12.0')
# Multiply
x = myokit.Multiply(a, b)
self.assertEqual(w.ex(x), '\\text{a}*12.0')
# Divide
x = myokit.Divide(a, b)
self.assertEqual(w.ex(x), '\\frac{\\text{a}}{12.0}')
# Quotient
# Not supported in latex!
x = myokit.Quotient(a, b)
self.assertEqual(
w.ex(x), '\\left\\lfloor\\frac{\\text{a}}{12.0}\\right\\rfloor')
# Remainder
x = myokit.Remainder(a, b)
self.assertEqual(w.ex(x), '\\bmod\\left(\\text{a},12.0\\right)')
# Power
x = myokit.Power(a, b)
self.assertEqual(w.ex(x), '\\text{a}^{12.0}')
# Power with brackets
x = myokit.Power(myokit.Plus(a, b), b)
self.assertEqual(w.ex(x), '\\left(\\text{a}+12.0\\right)^{12.0}')
# Sqrt
x = myokit.Sqrt(b)
self.assertEqual(w.ex(x), '\\sqrt{12.0}')
# Exp
x = myokit.Exp(a)
self.assertEqual(w.ex(x), '\\exp\\left(\\text{a}\\right)')
# Log(a)
x = myokit.Log(b)
self.assertEqual(w.ex(x), '\\log\\left(12.0\\right)')
# Log(a, b)
x = myokit.Log(a, b)
self.assertEqual(w.ex(x), '\\log_{12.0}\\left(\\text{a}\\right)')
# Log10
x = myokit.Log10(b)
self.assertEqual(w.ex(x), '\\log_{10.0}\\left(12.0\\right)')
# Sin
x = myokit.Sin(b)
self.assertEqual(w.ex(x), '\\sin\\left(12.0\\right)')
# Cos
x = myokit.Cos(b)
self.assertEqual(w.ex(x), '\\cos\\left(12.0\\right)')
# Tan
x = myokit.Tan(b)
self.assertEqual(w.ex(x), '\\tan\\left(12.0\\right)')
# ASin
x = myokit.ASin(b)
self.assertEqual(w.ex(x), '\\arcsin\\left(12.0\\right)')
# ACos
x = myokit.ACos(b)
self.assertEqual(w.ex(x), '\\arccos\\left(12.0\\right)')
# ATan
x = myokit.ATan(b)
self.assertEqual(w.ex(x), '\\arctan\\left(12.0\\right)')
# Floor
x = myokit.Floor(b)
self.assertEqual(w.ex(x), '\\left\\lfloor{12.0}\\right\\rfloor')
# Ceil
x = myokit.Ceil(b)
self.assertEqual(w.ex(x), '\\left\\lceil{12.0}\\right\\rceil')
# Abs
x = myokit.Abs(b)
self.assertEqual(w.ex(x), '\\lvert{12.0}\\rvert')
# Equal
x = myokit.Equal(a, b)
self.assertEqual(w.ex(x), '\\left(\\text{a}=12.0\\right)')
# NotEqual
x = myokit.NotEqual(a, b)
self.assertEqual(w.ex(x), '\\left(\\text{a}\\neq12.0\\right)')
# More
x = myokit.More(a, b)
self.assertEqual(w.ex(x), '\\left(\\text{a}>12.0\\right)')
# Less
x = myokit.Less(a, b)
self.assertEqual(w.ex(x), '\\left(\\text{a}<12.0\\right)')
# MoreEqual
x = myokit.MoreEqual(a, b)
self.assertEqual(w.ex(x), '\\left(\\text{a}\\geq12.0\\right)')
# LessEqual
x = myokit.LessEqual(a, b)
self.assertEqual(w.ex(x), '\\left(\\text{a}\\leq12.0\\right)')
# Not
cond1 = myokit.parse_expression('5 > 3')
cond2 = myokit.parse_expression('2 < 1')
x = myokit.Not(cond1)
self.assertEqual(w.ex(x), '\\not\\left(\\left(5.0>3.0\\right)\\right)')
# And
x = myokit.And(cond1, cond2)
self.assertEqual(
w.ex(x), '\\left(\\left(5.0>3.0\\right)\\and'
'\\left(2.0<1.0\\right)\\right)')
# Or
x = myokit.Or(cond1, cond2)
self.assertEqual(
w.ex(x), '\\left(\\left(5.0>3.0\\right)\\or'
'\\left(2.0<1.0\\right)\\right)')
# If
x = myokit.If(cond1, a, b)
self.assertEqual(
w.ex(x), 'if\\left(\\left(5.0>3.0\\right),\\text{a},12.0\\right)')
# Piecewise
c = myokit.Number(1)
x = myokit.Piecewise(cond1, a, cond2, b, c)
self.assertEqual(
w.ex(x), 'piecewise\\left(\\left(5.0>3.0\\right),\\text{a},'
'\\left(2.0<1.0\\right),12.0,1.0\\right)')
# Test fetching using ewriter method
w = myokit.formats.ewriter('latex')
self.assertIsInstance(w, myokit.formats.latex.LatexExpressionWriter)
# Test without a Myokit expression
self.assertRaisesRegex(ValueError, 'Unknown expression type', w.ex, 7)
def test_all(self):
# Single and double precision
ws = myokit.formats.cuda.CudaExpressionWriter()
wd = myokit.formats.cuda.CudaExpressionWriter(myokit.DOUBLE_PRECISION)
model = myokit.Model()
component = model.add_component('c')
avar = component.add_variable('a')
# Name
a = myokit.Name(avar)
self.assertEqual(ws.ex(a), 'c.a')
self.assertEqual(wd.ex(a), 'c.a')
# Number with unit
b = myokit.Number('12', 'pF')
self.assertEqual(ws.ex(b), '12.0f')
self.assertEqual(wd.ex(b), '12.0')
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertEqual(ws.ex(x), '12.0f')
self.assertEqual(wd.ex(x), '12.0')
# Prefix minus
x = myokit.PrefixMinus(b)
self.assertEqual(ws.ex(x), '(-12.0f)')
self.assertEqual(wd.ex(x), '(-12.0)')
# Plus
x = myokit.Plus(a, b)
self.assertEqual(ws.ex(x), 'c.a + 12.0f')
self.assertEqual(wd.ex(x), 'c.a + 12.0')
# Minus
x = myokit.Minus(a, b)
self.assertEqual(ws.ex(x), 'c.a - 12.0f')
self.assertEqual(wd.ex(x), 'c.a - 12.0')
# Multiply
x = myokit.Multiply(a, b)
self.assertEqual(ws.ex(x), 'c.a * 12.0f')
self.assertEqual(wd.ex(x), 'c.a * 12.0')
# Divide
x = myokit.Divide(a, b)
self.assertEqual(ws.ex(x), 'c.a / 12.0f')
self.assertEqual(wd.ex(x), 'c.a / 12.0')
# Quotient
x = myokit.Quotient(a, b)
self.assertEqual(ws.ex(x), 'floorf(c.a / 12.0f)')
self.assertEqual(wd.ex(x), 'floor(c.a / 12.0)')
# Remainder
x = myokit.Remainder(a, b)
self.assertEqual(ws.ex(x), 'c.a - 12.0f * (floorf(c.a / 12.0f))')
self.assertEqual(wd.ex(x), 'c.a - 12.0 * (floor(c.a / 12.0))')
# Power
x = myokit.Power(a, b)
self.assertEqual(ws.ex(x), 'powf(c.a, 12.0f)')
self.assertEqual(wd.ex(x), 'pow(c.a, 12.0)')
# Square
x = myokit.Power(a, myokit.Number(2))
self.assertEqual(ws.ex(x), '(c.a * c.a)')
self.assertEqual(wd.ex(x), '(c.a * c.a)')
# Square with brackets
x = myokit.Power(myokit.Plus(a, b), myokit.Number(2))
self.assertEqual(ws.ex(x), '((c.a + 12.0f) * (c.a + 12.0f))')
self.assertEqual(wd.ex(x), '((c.a + 12.0) * (c.a + 12.0))')
# Sqrt
x = myokit.Sqrt(b)
self.assertEqual(ws.ex(x), 'sqrtf(12.0f)')
self.assertEqual(wd.ex(x), 'sqrt(12.0)')
# Exp
x = myokit.Exp(a)
self.assertEqual(ws.ex(x), 'expf(c.a)')
self.assertEqual(wd.ex(x), 'exp(c.a)')
# Log(a)
x = myokit.Log(b)
self.assertEqual(ws.ex(x), 'logf(12.0f)')
self.assertEqual(wd.ex(x), 'log(12.0)')
# Log(a, b)
x = myokit.Log(a, b)
self.assertEqual(ws.ex(x), '(logf(c.a) / logf(12.0f))')
self.assertEqual(wd.ex(x), '(log(c.a) / log(12.0))')
# Log10
x = myokit.Log10(b)
self.assertEqual(ws.ex(x), 'log10f(12.0f)')
self.assertEqual(wd.ex(x), 'log10(12.0)')
# Sin
x = myokit.Sin(b)
self.assertEqual(ws.ex(x), 'sinf(12.0f)')
self.assertEqual(wd.ex(x), 'sin(12.0)')
# Cos
x = myokit.Cos(b)
self.assertEqual(ws.ex(x), 'cosf(12.0f)')
self.assertEqual(wd.ex(x), 'cos(12.0)')
# Tan
x = myokit.Tan(b)
self.assertEqual(ws.ex(x), 'tanf(12.0f)')
self.assertEqual(wd.ex(x), 'tan(12.0)')
# ASin
x = myokit.ASin(b)
self.assertEqual(ws.ex(x), 'asinf(12.0f)')
self.assertEqual(wd.ex(x), 'asin(12.0)')
# ACos
x = myokit.ACos(b)
self.assertEqual(ws.ex(x), 'acosf(12.0f)')
self.assertEqual(wd.ex(x), 'acos(12.0)')
# ATan
x = myokit.ATan(b)
self.assertEqual(ws.ex(x), 'atanf(12.0f)')
self.assertEqual(wd.ex(x), 'atan(12.0)')
# Floor
x = myokit.Floor(b)
self.assertEqual(ws.ex(x), 'floorf(12.0f)')
self.assertEqual(wd.ex(x), 'floor(12.0)')
# Ceil
x = myokit.Ceil(b)
self.assertEqual(ws.ex(x), 'ceilf(12.0f)')
self.assertEqual(wd.ex(x), 'ceil(12.0)')
# Abs
x = myokit.Abs(b)
self.assertEqual(ws.ex(x), 'fabsf(12.0f)')
self.assertEqual(wd.ex(x), 'fabs(12.0)')
# Equal
x = myokit.Equal(a, b)
self.assertEqual(ws.ex(x), '(c.a == 12.0f)')
self.assertEqual(wd.ex(x), '(c.a == 12.0)')
# NotEqual
x = myokit.NotEqual(a, b)
self.assertEqual(ws.ex(x), '(c.a != 12.0f)')
self.assertEqual(wd.ex(x), '(c.a != 12.0)')
# More
x = myokit.More(a, b)
self.assertEqual(ws.ex(x), '(c.a > 12.0f)')
self.assertEqual(wd.ex(x), '(c.a > 12.0)')
# Less
x = myokit.Less(a, b)
self.assertEqual(ws.ex(x), '(c.a < 12.0f)')
self.assertEqual(wd.ex(x), '(c.a < 12.0)')
# MoreEqual
x = myokit.MoreEqual(a, b)
self.assertEqual(ws.ex(x), '(c.a >= 12.0f)')
self.assertEqual(wd.ex(x), '(c.a >= 12.0)')
# LessEqual
x = myokit.LessEqual(a, b)
self.assertEqual(ws.ex(x), '(c.a <= 12.0f)')
self.assertEqual(wd.ex(x), '(c.a <= 12.0)')
# Not
cond1 = myokit.parse_expression('5 > 3')
cond2 = myokit.parse_expression('2 < 1')
x = myokit.Not(cond1)
self.assertEqual(ws.ex(x), '!((5.0f > 3.0f))')
self.assertEqual(wd.ex(x), '!((5.0 > 3.0))')
# And
x = myokit.And(cond1, cond2)
self.assertEqual(ws.ex(x), '((5.0f > 3.0f) && (2.0f < 1.0f))')
self.assertEqual(wd.ex(x), '((5.0 > 3.0) && (2.0 < 1.0))')
# Or
x = myokit.Or(cond1, cond2)
self.assertEqual(ws.ex(x), '((5.0f > 3.0f) || (2.0f < 1.0f))')
self.assertEqual(wd.ex(x), '((5.0 > 3.0) || (2.0 < 1.0))')
# If
x = myokit.If(cond1, a, b)
self.assertEqual(ws.ex(x), '((5.0f > 3.0f) ? c.a : 12.0f)')
self.assertEqual(wd.ex(x), '((5.0 > 3.0) ? c.a : 12.0)')
# Piecewise
c = myokit.Number(1)
x = myokit.Piecewise(cond1, a, cond2, b, c)
self.assertEqual(
ws.ex(x), '((5.0f > 3.0f) ? c.a : ((2.0f < 1.0f) ? 12.0f : 1.0f))')
self.assertEqual(wd.ex(x),
'((5.0 > 3.0) ? c.a : ((2.0 < 1.0) ? 12.0 : 1.0))')
# Test fetching using ewriter method
w = myokit.formats.ewriter('cuda')
self.assertIsInstance(w, myokit.formats.cuda.CudaExpressionWriter)
# Test without a Myokit expression
self.assertRaisesRegex(ValueError, 'Unknown expression type', w.ex, 7)
def test_basic(self):
# Single and double precision and native maths
ws = myokit.formats.opencl.OpenCLExpressionWriter()
wd = myokit.formats.opencl.OpenCLExpressionWriter(
myokit.DOUBLE_PRECISION)
wn = myokit.formats.opencl.OpenCLExpressionWriter(native_math=False)
a = myokit.Name(myokit.Model().add_component('c').add_variable('a'))
b = myokit.Number('12', 'pF')
# Name
self.assertEqual(ws.ex(a), 'c.a')
self.assertEqual(wd.ex(a), 'c.a')
self.assertEqual(wn.ex(a), 'c.a')
# Number with unit
self.assertEqual(ws.ex(b), '12.0f')
self.assertEqual(wd.ex(b), '12.0')
self.assertEqual(wn.ex(b), '12.0f')
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertEqual(ws.ex(x), '12.0f')
self.assertEqual(wd.ex(x), '12.0')
self.assertEqual(wn.ex(x), '12.0f')
# Prefix minus
x = myokit.PrefixMinus(b)
self.assertEqual(ws.ex(x), '(-12.0f)')
self.assertEqual(wd.ex(x), '(-12.0)')
self.assertEqual(wn.ex(x), '(-12.0f)')
# Plus
x = myokit.Plus(a, b)
self.assertEqual(ws.ex(x), 'c.a + 12.0f')
self.assertEqual(wd.ex(x), 'c.a + 12.0')
self.assertEqual(wn.ex(x), 'c.a + 12.0f')
# Minus
x = myokit.Minus(a, b)
self.assertEqual(ws.ex(x), 'c.a - 12.0f')
self.assertEqual(wd.ex(x), 'c.a - 12.0')
self.assertEqual(wn.ex(x), 'c.a - 12.0f')
# Multiply
x = myokit.Multiply(a, b)
self.assertEqual(ws.ex(x), 'c.a * 12.0f')
self.assertEqual(wd.ex(x), 'c.a * 12.0')
self.assertEqual(wn.ex(x), 'c.a * 12.0f')
# Divide
x = myokit.Divide(a, b)
self.assertEqual(ws.ex(x), 'c.a / 12.0f')
self.assertEqual(wd.ex(x), 'c.a / 12.0')
self.assertEqual(wn.ex(x), 'c.a / 12.0f')
# Quotient
x = myokit.Quotient(a, b)
self.assertEqual(ws.ex(x), 'floor(c.a / 12.0f)')
self.assertEqual(wd.ex(x), 'floor(c.a / 12.0)')
self.assertEqual(wn.ex(x), 'floor(c.a / 12.0f)')
# Remainder
x = myokit.Remainder(a, b)
self.assertEqual(ws.ex(x), 'c.a - 12.0f * (floor(c.a / 12.0f))')
self.assertEqual(wd.ex(x), 'c.a - 12.0 * (floor(c.a / 12.0))')
self.assertEqual(wn.ex(x), 'c.a - 12.0f * (floor(c.a / 12.0f))')
def test_reader_writer(self):
# Test using the proper reader/writer
try:
import sympy as sp
except ImportError:
print('Sympy not found, skipping test.')
return
# Create writer and reader
w = mypy.SymPyExpressionWriter()
r = mypy.SymPyExpressionReader(self._model)
# Name
a = self._a
ca = sp.Symbol('c.a')
self.assertEqual(w.ex(a), ca)
self.assertEqual(r.ex(ca), a)
# Number with unit
b = myokit.Number('12', 'pF')
cb = sp.Float(12)
self.assertEqual(w.ex(b), cb)
# Note: Units are lost in sympy im/ex-port!
#self.assertEqual(r.ex(cb), b)
# Number without unit
b = myokit.Number('12')
cb = sp.Float(12)
self.assertEqual(w.ex(b), cb)
self.assertEqual(r.ex(cb), b)
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertEqual(w.ex(x), cb)
# Note: Sympy doesn't seem to have a prefix plus
self.assertEqual(r.ex(cb), b)
# Prefix minus
# Note: SymPy treats -x as Mul(NegativeOne, x)
# But for numbers just returns a number with a negative value
x = myokit.PrefixMinus(b)
self.assertEqual(w.ex(x), -cb)
self.assertEqual(float(r.ex(-cb)), float(x))
# Plus
x = myokit.Plus(a, b)
self.assertEqual(w.ex(x), ca + cb)
# Note: SymPy likes to re-order the operands...
self.assertEqual(float(r.ex(ca + cb)), float(x))
# Minus
x = myokit.Minus(a, b)
self.assertEqual(w.ex(x), ca - cb)
self.assertEqual(float(r.ex(ca - cb)), float(x))
# Multiply
x = myokit.Multiply(a, b)
self.assertEqual(w.ex(x), ca * cb)
self.assertEqual(float(r.ex(ca * cb)), float(x))
# Divide
x = myokit.Divide(a, b)
self.assertEqual(w.ex(x), ca / cb)
self.assertEqual(float(r.ex(ca / cb)), float(x))
# Quotient
x = myokit.Quotient(a, b)
self.assertEqual(w.ex(x), ca // cb)
self.assertEqual(float(r.ex(ca // cb)), float(x))
# Remainder
x = myokit.Remainder(a, b)
self.assertEqual(w.ex(x), ca % cb)
self.assertEqual(float(r.ex(ca % cb)), float(x))
# Power
x = myokit.Power(a, b)
self.assertEqual(w.ex(x), ca**cb)
self.assertEqual(float(r.ex(ca**cb)), float(x))
# Sqrt
x = myokit.Sqrt(a)
cx = sp.sqrt(ca)
self.assertEqual(w.ex(x), cx)
# Note: SymPy converts sqrt to power
self.assertEqual(float(r.ex(cx)), float(x))
# Exp
x = myokit.Exp(a)
cx = sp.exp(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Log(a)
x = myokit.Log(a)
cx = sp.log(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Log(a, b)
x = myokit.Log(a, b)
cx = sp.log(ca, cb)
self.assertEqual(w.ex(x), cx)
self.assertEqual(float(r.ex(cx)), float(x))
# Log10
x = myokit.Log10(b)
cx = sp.log(cb, 10)
self.assertEqual(w.ex(x), cx)
self.assertAlmostEqual(float(r.ex(cx)), float(x))
# Sin
x = myokit.Sin(a)
cx = sp.sin(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Cos
x = myokit.Cos(a)
cx = sp.cos(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Tan
x = myokit.Tan(a)
cx = sp.tan(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# ASin
x = myokit.ASin(a)
cx = sp.asin(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# ACos
x = myokit.ACos(a)
cx = sp.acos(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# ATan
x = myokit.ATan(a)
cx = sp.atan(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Floor
x = myokit.Floor(a)
cx = sp.floor(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Ceil
x = myokit.Ceil(a)
cx = sp.ceiling(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Abs
x = myokit.Abs(a)
cx = sp.Abs(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Equal
x = myokit.Equal(a, b)
cx = sp.Eq(ca, cb)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# NotEqual
x = myokit.NotEqual(a, b)
cx = sp.Ne(ca, cb)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# More
x = myokit.More(a, b)
cx = sp.Gt(ca, cb)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Less
x = myokit.Less(a, b)
cx = sp.Lt(ca, cb)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# MoreEqual
x = myokit.MoreEqual(a, b)
cx = sp.Ge(ca, cb)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# LessEqual
x = myokit.LessEqual(a, b)
cx = sp.Le(ca, cb)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Not
x = myokit.Not(a)
cx = sp.Not(ca)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# And
cond1 = myokit.More(a, b)
cond2 = myokit.Less(a, b)
c1 = sp.Gt(ca, cb)
c2 = sp.Lt(ca, cb)
x = myokit.And(cond1, cond2)
cx = sp.And(c1, c2)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Or
x = myokit.Or(cond1, cond2)
cx = sp.Or(c1, c2)
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# If
# Note: sympy only does piecewise, not if
x = myokit.If(cond1, a, b)
cx = sp.Piecewise((ca, c1), (cb, True))
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x.piecewise())
# Piecewise
c = myokit.Number(1)
cc = sp.Float(1)
x = myokit.Piecewise(cond1, a, cond2, b, c)
cx = sp.Piecewise((ca, c1), (cb, c2), (cc, True))
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Myokit piecewise's (like CellML's) always have a final True
# condition (i.e. an 'else'). SymPy doesn't require this, so test if
# we can import this --> It will add an "else 0"
x = myokit.Piecewise(cond1, a, myokit.Number(0))
cx = sp.Piecewise((ca, c1))
self.assertEqual(r.ex(cx), x)
# SymPy function without Myokit equivalent --> Should raise exception
cu = sp.principal_branch(cx, cc)
self.assertRaisesRegex(ValueError, 'Unsupported type', r.ex, cu)
# Derivative
m = self._model.clone()
avar = m.get('c.a')
r = mypy.SymPyExpressionReader(self._model)
avar.promote(4)
x = myokit.Derivative(self._a)
cx = sp.symbols('dot(c.a)')
self.assertEqual(w.ex(x), cx)
self.assertEqual(r.ex(cx), x)
# Equation
e = myokit.Equation(a, b)
ce = sp.Eq(ca, cb)
self.assertEqual(w.eq(e), ce)
# There's no backwards equivalent for this!
# The ereader can handle it, but it becomes and Equals expression.
# Test sympy division
del (m, avar, x, cx, e, ce)
a = self._model.get('c.a')
b = self._model.get('c').add_variable('bbb')
b.set_rhs('1 / a')
e = b.rhs()
ce = w.ex(b.rhs())
e = r.ex(ce)
self.assertEqual(
e,
myokit.Multiply(myokit.Number(1),
myokit.Power(myokit.Name(a), myokit.Number(-1))))
# Test sympy negative numbers
a = self._model.get('c.a')
e1 = myokit.PrefixMinus(myokit.Name(a))
ce = w.ex(e1)
e2 = r.ex(ce)
self.assertEqual(e1, e2)
def test_all(self):
w = myokit.formats.ewriter('easyml')
model = myokit.Model()
component = model.add_component('c')
avar = component.add_variable('a')
# Name
a = myokit.Name(avar)
self.assertEqual(w.ex(a), 'c.a')
# Number with unit
b = myokit.Number('12', 'pF')
self.assertEqual(w.ex(b), '12.0')
# Integer
c = myokit.Number(1)
self.assertEqual(w.ex(c), '1.0')
# Integer
# Prefix plus
x = myokit.PrefixPlus(b)
self.assertEqual(w.ex(x), '12.0')
# Prefix minus
x = myokit.PrefixMinus(b)
self.assertEqual(w.ex(x), '(-12.0)')
# Plus
x = myokit.Plus(a, b)
self.assertEqual(w.ex(x), 'c.a + 12.0')
# Minus
x = myokit.Minus(a, b)
self.assertEqual(w.ex(x), 'c.a - 12.0')
# Multiply
x = myokit.Multiply(a, b)
self.assertEqual(w.ex(x), 'c.a * 12.0')
# Divide
x = myokit.Divide(a, b)
self.assertEqual(w.ex(x), 'c.a / 12.0')
# Quotient
x = myokit.Quotient(a, b)
with WarningCollector() as c:
self.assertEqual(w.ex(x), 'floor(c.a / 12.0)')
# Remainder
x = myokit.Remainder(a, b)
with WarningCollector() as c:
self.assertEqual(w.ex(x), 'c.a - 12.0 * (floor(c.a / 12.0))')
# Power
x = myokit.Power(a, b)
self.assertEqual(w.ex(x), 'pow(c.a, 12.0)')
# Sqrt
x = myokit.Sqrt(b)
self.assertEqual(w.ex(x), 'sqrt(12.0)')
# Exp
x = myokit.Exp(a)
self.assertEqual(w.ex(x), 'exp(c.a)')
# Log(a)
x = myokit.Log(b)
self.assertEqual(w.ex(x), 'log(12.0)')
# Log(a, b)
x = myokit.Log(a, b)
self.assertEqual(w.ex(x), '(log(c.a) / log(12.0))')
# Log10
x = myokit.Log10(b)
self.assertEqual(w.ex(x), 'log10(12.0)')
# Sin
with WarningCollector() as c:
x = myokit.Sin(b)
self.assertEqual(w.ex(x), 'sin(12.0)')
# Cos
x = myokit.Cos(b)
self.assertEqual(w.ex(x), 'cos(12.0)')
# Tan
x = myokit.Tan(b)
self.assertEqual(w.ex(x), 'tan(12.0)')
# ASin
x = myokit.ASin(b)
self.assertEqual(w.ex(x), 'asin(12.0)')
# ACos
x = myokit.ACos(b)
self.assertEqual(w.ex(x), 'acos(12.0)')
# ATan
x = myokit.ATan(b)
self.assertEqual(w.ex(x), 'atan(12.0)')
with WarningCollector() as c:
# Floor
x = myokit.Floor(b)
self.assertEqual(w.ex(x), 'floor(12.0)')
# Ceil
x = myokit.Ceil(b)
self.assertEqual(w.ex(x), 'ceil(12.0)')
# Abs
x = myokit.Abs(b)
self.assertEqual(w.ex(x), 'fabs(12.0)')
# Equal
x = myokit.Equal(a, b)
self.assertEqual(w.ex(x), '(c.a == 12.0)')
# NotEqual
x = myokit.NotEqual(a, b)
self.assertEqual(w.ex(x), '(c.a != 12.0)')
# More
x = myokit.More(a, b)
self.assertEqual(w.ex(x), '(c.a > 12.0)')
# Less
x = myokit.Less(a, b)
self.assertEqual(w.ex(x), '(c.a < 12.0)')
# MoreEqual
x = myokit.MoreEqual(a, b)
self.assertEqual(w.ex(x), '(c.a >= 12.0)')
# LessEqual
x = myokit.LessEqual(a, b)
self.assertEqual(w.ex(x), '(c.a <= 12.0)')
# Not
cond1 = myokit.parse_expression('5 > 3')
cond2 = myokit.parse_expression('2 < 1')
x = myokit.Not(cond1)
self.assertEqual(w.ex(x), '!((5.0 > 3.0))')
# And
x = myokit.And(cond1, cond2)
self.assertEqual(w.ex(x), '((5.0 > 3.0) and (2.0 < 1.0))')
# Or
x = myokit.Or(cond1, cond2)
self.assertEqual(w.ex(x), '((5.0 > 3.0) or (2.0 < 1.0))')
# If
x = myokit.If(cond1, a, b)
self.assertEqual(w.ex(x), '((5.0 > 3.0) ? c.a : 12.0)')
# Piecewise
c = myokit.Number(1)
x = myokit.Piecewise(cond1, a, cond2, b, c)
self.assertEqual(w.ex(x),
'((5.0 > 3.0) ? c.a : ((2.0 < 1.0) ? 12.0 : 1.0))')
# Test without a Myokit expression
self.assertRaisesRegex(ValueError, 'Unknown expression type', w.ex, 7)
