def test_periodic_argument():
from sympy import (periodic_argument, unbranched_argument, oo,
principal_branch, polar_lift, pi)
x = Symbol('x')
p = Symbol('p', positive=True)
assert unbranched_argument(2 + I) == periodic_argument(2 + I, oo)
assert unbranched_argument(1 + x) == periodic_argument(1 + x, oo)
assert N_equals(unbranched_argument((1 + I)**2), pi/2)
assert N_equals(unbranched_argument((1 - I)**2), -pi/2)
assert N_equals(periodic_argument((1 + I)**2, 3*pi), pi/2)
assert N_equals(periodic_argument((1 - I)**2, 3*pi), -pi/2)
assert unbranched_argument(principal_branch(x, pi)) == \
periodic_argument(x, pi)
assert unbranched_argument(polar_lift(2 + I)) == unbranched_argument(2 + I)
assert periodic_argument(polar_lift(2 + I), 2*pi) == \
periodic_argument(2 + I, 2*pi)
assert periodic_argument(polar_lift(2 + I), 3*pi) == \
periodic_argument(2 + I, 3*pi)
assert periodic_argument(polar_lift(2 + I), pi) == \
periodic_argument(polar_lift(2 + I), pi)
assert unbranched_argument(polar_lift(1 + I)) == pi/4
assert periodic_argument(2*p, p) == periodic_argument(p, p)
assert periodic_argument(pi*p, p) == periodic_argument(p, p)
assert Abs(polar_lift(1 + I)) == Abs(1 + I)
def test_periodic_argument():
from sympy import (periodic_argument, unbranched_argument, oo,
principal_branch, polar_lift, pi)
x = Symbol('x')
p = Symbol('p', positive=True)
assert unbranched_argument(2 + I) == periodic_argument(2 + I, oo)
assert unbranched_argument(1 + x) == periodic_argument(1 + x, oo)
assert N_equals(unbranched_argument((1 + I)**2), pi / 2)
assert N_equals(unbranched_argument((1 - I)**2), -pi / 2)
assert N_equals(periodic_argument((1 + I)**2, 3 * pi), pi / 2)
assert N_equals(periodic_argument((1 - I)**2, 3 * pi), -pi / 2)
assert unbranched_argument(principal_branch(x, pi)) == \
periodic_argument(x, pi)
assert unbranched_argument(polar_lift(2 + I)) == unbranched_argument(2 + I)
assert periodic_argument(polar_lift(2 + I), 2*pi) == \
periodic_argument(2 + I, 2*pi)
assert periodic_argument(polar_lift(2 + I), 3*pi) == \
periodic_argument(2 + I, 3*pi)
assert periodic_argument(polar_lift(2 + I), pi) == \
periodic_argument(polar_lift(2 + I), pi)
assert unbranched_argument(polar_lift(1 + I)) == pi / 4
assert periodic_argument(2 * p, p) == periodic_argument(p, p)
assert periodic_argument(pi * p, p) == periodic_argument(p, p)
assert Abs(polar_lift(1 + I)) == Abs(1 + I)
def test_periodic_argument():
from sympy import (periodic_argument, unbranched_argument, oo,
principal_branch, polar_lift, pi)
x = Symbol('x')
p = Symbol('p', positive = True)
def tn(a, b):
from sympy.utilities.randtest import test_numerically
from sympy import Dummy
return test_numerically(a, b, Dummy('x'))
assert unbranched_argument(2 + I) == periodic_argument(2 + I, oo)
assert unbranched_argument(1 + x) == periodic_argument(1 + x, oo)
assert tn(unbranched_argument((1+I)**2), pi/2)
assert tn(unbranched_argument((1-I)**2), -pi/2)
assert tn(periodic_argument((1+I)**2, 3*pi), pi/2)
assert tn(periodic_argument((1-I)**2, 3*pi), -pi/2)
assert unbranched_argument(principal_branch(x, pi)) \
== periodic_argument(x, pi)
assert unbranched_argument(polar_lift(2 + I)) == unbranched_argument(2 + I)
assert periodic_argument(polar_lift(2 + I), 2*pi) \
== periodic_argument(2 + I, 2*pi)
assert periodic_argument(polar_lift(2 + I), 3*pi) \
== periodic_argument(2 + I, 3*pi)
assert periodic_argument(polar_lift(2 + I), pi) \
== periodic_argument(polar_lift(2 + I), pi)
assert unbranched_argument(polar_lift(1 + I)) == pi/4
assert periodic_argument(2*p, p) == periodic_argument(p, p)
assert periodic_argument(pi*p, p) == periodic_argument(p, p)
def test_periodic_argument():
from sympy import (periodic_argument, unbranched_argument, oo,
principal_branch, polar_lift)
x = Symbol('x')
def tn(a, b):
from sympy.utilities.randtest import test_numerically
from sympy import Dummy
return test_numerically(a, b, Dummy('x'))
assert unbranched_argument(2 + I) == periodic_argument(2 + I, oo)
assert unbranched_argument(1 + x) == periodic_argument(1 + x, oo)
assert tn(unbranched_argument((1+I)**2), pi/2)
assert tn(unbranched_argument((1-I)**2), -pi/2)
assert tn(periodic_argument((1+I)**2, 3*pi), pi/2)
assert tn(periodic_argument((1-I)**2, 3*pi), -pi/2)
assert unbranched_argument(principal_branch(x, pi)) \
== periodic_argument(x, pi)
assert unbranched_argument(polar_lift(2 + I)) == unbranched_argument(2 + I)
assert periodic_argument(polar_lift(2 + I), 2*pi) \
== periodic_argument(2 + I, 2*pi)
assert periodic_argument(polar_lift(2 + I), 3*pi) \
== periodic_argument(2 + I, 3*pi)
assert periodic_argument(polar_lift(2 + I), pi) \
== periodic_argument(polar_lift(2 + I), pi)
def test_unpolarify():
from sympy import (exp_polar, polar_lift, exp, unpolarify,
principal_branch)
from sympy import gamma, erf, sin, tanh, uppergamma, Eq, Ne
from sympy.abc import x
p = exp_polar(7 * I) + 1
u = exp(7 * I) + 1
assert unpolarify(1) == 1
assert unpolarify(p) == u
assert unpolarify(p**2) == u**2
assert unpolarify(p**x) == p**x
assert unpolarify(p * x) == u * x
assert unpolarify(p + x) == u + x
assert unpolarify(sqrt(sin(p))) == sqrt(sin(u))
# Test reduction to principal branch 2*pi.
t = principal_branch(x, 2 * pi)
assert unpolarify(t) == x
assert unpolarify(sqrt(t)) == sqrt(t)
# Test exponents_only.
assert unpolarify(p**p, exponents_only=True) == p**u
assert unpolarify(uppergamma(x, p**p)) == uppergamma(x, p**u)
# Test functions.
assert unpolarify(sin(p)) == sin(u)
assert unpolarify(tanh(p)) == tanh(u)
assert unpolarify(gamma(p)) == gamma(u)
assert unpolarify(erf(p)) == erf(u)
assert unpolarify(uppergamma(x, p)) == uppergamma(x, p)
assert unpolarify(uppergamma(sin(p), sin(p + exp_polar(0)))) == \
uppergamma(sin(u), sin(u + 1))
assert unpolarify(uppergamma(polar_lift(0), 2*exp_polar(0))) == \
uppergamma(0, 2)
assert unpolarify(Eq(p, 0)) == Eq(u, 0)
assert unpolarify(Ne(p, 0)) == Ne(u, 0)
assert unpolarify(polar_lift(x) > 0) == (x > 0)
# Test bools
assert unpolarify(True) is True
def test_unpolarify():
from sympy import (exp_polar, polar_lift, exp, unpolarify,
principal_branch)
from sympy import gamma, erf, sin, tanh, uppergamma, Eq, Ne
from sympy.abc import x
p = exp_polar(7*I) + 1
u = exp(7*I) + 1
assert unpolarify(1) == 1
assert unpolarify(p) == u
assert unpolarify(p**2) == u**2
assert unpolarify(p**x) == p**x
assert unpolarify(p*x) == u*x
assert unpolarify(p + x) == u + x
assert unpolarify(sqrt(sin(p))) == sqrt(sin(u))
# Test reduction to principal branch 2*pi.
t = principal_branch(x, 2*pi)
assert unpolarify(t) == x
assert unpolarify(sqrt(t)) == sqrt(t)
# Test exponents_only.
assert unpolarify(p**p, exponents_only=True) == p**u
assert unpolarify(uppergamma(x, p**p)) == uppergamma(x, p**u)
# Test functions.
assert unpolarify(sin(p)) == sin(u)
assert unpolarify(tanh(p)) == tanh(u)
assert unpolarify(gamma(p)) == gamma(u)
assert unpolarify(erf(p)) == erf(u)
assert unpolarify(uppergamma(x, p)) == uppergamma(x, p)
assert unpolarify(uppergamma(sin(p), sin(p + exp_polar(0)))) == \
uppergamma(sin(u), sin(u + 1))
assert unpolarify(uppergamma(polar_lift(0), 2*exp_polar(0))) == \
uppergamma(0, 2)
assert unpolarify(Eq(p, 0)) == Eq(u, 0)
assert unpolarify(Ne(p, 0)) == Ne(u, 0)
assert unpolarify(polar_lift(x) > 0) == (x > 0)
# Test bools
assert unpolarify(True) is True
def test_principal_branch():
from sympy import principal_branch, polar_lift, exp_polar
p = Symbol('p', positive=True)
x = Symbol('x')
neg = Symbol('x', negative=True)
assert principal_branch(polar_lift(x), p) == principal_branch(x, p)
assert principal_branch(polar_lift(2 + I), p) == principal_branch(2 + I, p)
assert principal_branch(2 * x, p) == 2 * principal_branch(x, p)
assert principal_branch(1, pi) == exp_polar(0)
assert principal_branch(-1, 2 * pi) == exp_polar(I * pi)
assert principal_branch(-1, pi) == exp_polar(0)
assert principal_branch(exp_polar(3*pi*I)*x, 2*pi) == \
principal_branch(exp_polar(I*pi)*x, 2*pi)
assert principal_branch(neg * exp_polar(pi * I),
2 * pi) == neg * exp_polar(-I * pi)
# related to issue #14692
assert principal_branch(exp_polar(-I*pi/2)/polar_lift(neg), 2*pi) == \
exp_polar(-I*pi/2)/neg
assert N_equals(principal_branch((1 + I)**2, 2 * pi), 2 * I)
assert N_equals(principal_branch((1 + I)**2, 3 * pi), 2 * I)
assert N_equals(principal_branch((1 + I)**2, 1 * pi), 2 * I)
# test argument sanitization
assert principal_branch(x, I).func is principal_branch
assert principal_branch(x, -4).func is principal_branch
assert principal_branch(x, -oo).func is principal_branch
assert principal_branch(x, zoo).func is principal_branch
def test_principal_branch_fail():
# TODO XXX why does abs(x)._eval_evalf() not fall back to global evalf?
assert N_equals(principal_branch((1 + I)**2, pi / 2), 0)
def test_principal_branch():
from sympy import principal_branch, polar_lift, exp_polar
p = Symbol('p', positive=True)
x = Symbol('x')
neg = Symbol('x', negative=True)
assert principal_branch(polar_lift(x), p) == principal_branch(x, p)
assert principal_branch(polar_lift(2 + I), p) == principal_branch(2 + I, p)
assert principal_branch(2*x, p) == 2*principal_branch(x, p)
assert principal_branch(1, pi) == exp_polar(0)
assert principal_branch(-1, 2*pi) == exp_polar(I*pi)
assert principal_branch(-1, pi) == exp_polar(0)
assert principal_branch(exp_polar(3*pi*I)*x, 2*pi) == \
principal_branch(exp_polar(I*pi)*x, 2*pi)
assert principal_branch(neg*exp_polar(pi*I), 2*pi) == neg*exp_polar(-I*pi)
def tn(a, b):
from sympy.utilities.randtest import test_numerically
from sympy import Dummy
return test_numerically(a, b, Dummy('x'))
assert tn(principal_branch((1 + I)**2, 2*pi), 2*I)
assert tn(principal_branch((1 + I)**2, 3*pi), 2*I)
assert tn(principal_branch((1 + I)**2, 1*pi), 2*I)
# test argument sanitization
assert principal_branch(x, I).func is principal_branch
assert principal_branch(x, -4).func is principal_branch
assert principal_branch(x, -oo).func is principal_branch
assert principal_branch(x, zoo).func is principal_branch
def test_principal_branch_fail():
# TODO XXX why does abs(x)._eval_evalf() not fall back to global evalf?
assert tn(principal_branch((1 + I)**2, pi/2), 0)
def test_principal_branch():
from sympy import principal_branch, polar_lift, exp_polar
p = Symbol('p', positive=True)
x = Symbol('x')
neg = Symbol('x', negative=True)
assert principal_branch(polar_lift(x), p) == principal_branch(x, p)
assert principal_branch(polar_lift(2 + I), p) == principal_branch(2 + I, p)
assert principal_branch(2*x, p) == 2*principal_branch(x, p)
assert principal_branch(1, pi) == exp_polar(0)
assert principal_branch(-1, 2*pi) == exp_polar(I*pi)
assert principal_branch(-1, pi) == exp_polar(0)
assert principal_branch(exp_polar(3*pi*I)*x, 2*pi) == \
principal_branch(exp_polar(I*pi)*x, 2*pi)
assert principal_branch(neg*exp_polar(pi*I), 2*pi) == neg*exp_polar(-I*pi)
assert N_equals(principal_branch((1 + I)**2, 2*pi), 2*I)
assert N_equals(principal_branch((1 + I)**2, 3*pi), 2*I)
assert N_equals(principal_branch((1 + I)**2, 1*pi), 2*I)
# test argument sanitization
assert principal_branch(x, I).func is principal_branch
assert principal_branch(x, -4).func is principal_branch
assert principal_branch(x, -oo).func is principal_branch
assert principal_branch(x, zoo).func is principal_branch
def test_principal_branch():
from sympy import principal_branch, polar_lift, exp_polar
p = Symbol('p', positive=True)
x = Symbol('x')
neg = Symbol('x', negative=True)
assert principal_branch(polar_lift(x), p) == principal_branch(x, p)
assert principal_branch(polar_lift(2 + I), p) == principal_branch(2 + I, p)
assert principal_branch(2*x, p) == 2*principal_branch(x, p)
assert principal_branch(1, pi) == exp_polar(0)
assert principal_branch(-1, 2*pi) == exp_polar(I*pi)
assert principal_branch(-1, pi) == exp_polar(0)
assert principal_branch(exp_polar(3*pi*I)*x, 2*pi) == \
principal_branch(exp_polar(I*pi)*x, 2*pi)
assert principal_branch(neg*exp_polar(pi*I), 2*pi) == neg*exp_polar(-I*pi)
def tn(a, b):
from sympy.utilities.randtest import test_numerically
from sympy import Dummy
return test_numerically(a, b, Dummy('x'))
assert tn(principal_branch((1 + I)**2, 2*pi), 2*I)
assert tn(principal_branch((1 + I)**2, 3*pi), 2*I)
assert tn(principal_branch((1 + I)**2, 1*pi), 2*I)
# test argument sanitization
assert principal_branch(x, I).func is principal_branch
assert principal_branch(x, -4).func is principal_branch
assert principal_branch(x, -oo).func is principal_branch
assert principal_branch(x, zoo).func is principal_branch
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)
