def test_exp_values():
k = Symbol('k', integer=True)
assert exp(nan) == nan
assert exp(oo) == oo
assert exp(-oo) == 0
assert exp(0) == 1
assert exp(1) == E
assert exp(-1 + x).as_base_exp() == (S.Exp1, x - 1)
assert exp(1 + x).as_base_exp() == (S.Exp1, x + 1)
assert exp(pi * I / 2) == I
assert exp(pi * I) == -1
assert exp(3 * pi * I / 2) == -I
assert exp(2 * pi * I) == 1
assert refine(exp(pi * I * 2 * k)) == 1
assert refine(exp(pi * I * 2 * (k + Rational(1, 2)))) == -1
assert refine(exp(pi * I * 2 * (k + Rational(1, 4)))) == I
assert refine(exp(pi * I * 2 * (k + Rational(3, 4)))) == -I
assert exp(log(x)) == x
assert exp(2 * log(x)) == x**2
assert exp(pi * log(x)) == x**pi
assert exp(17 * log(x) + E * log(y)) == x**17 * y**E
assert exp(x * log(x)) != x**x
assert exp(sin(x) * log(x)) != x
assert exp(3 * log(x) + oo * x) == exp(oo * x) * x**3
assert exp(4 * log(x) * log(y) +
3 * log(x)) == x**3 * exp(4 * log(x) * log(y))
def test_exp_values():
k = Symbol('k', integer=True)
assert exp(nan) == nan
assert exp(oo) == oo
assert exp(-oo) == 0
assert exp(0) == 1
assert exp(1) == E
assert exp(-1 + x).as_base_exp() == (S.Exp1, x - 1)
assert exp(1 + x).as_base_exp() == (S.Exp1, x + 1)
assert exp(pi*I/2) == I
assert exp(pi*I) == -1
assert exp(3*pi*I/2) == -I
assert exp(2*pi*I) == 1
assert refine(exp(pi*I*2*k)) == 1
assert refine(exp(pi*I*2*(k + Rational(1, 2)))) == -1
assert refine(exp(pi*I*2*(k + Rational(1, 4)))) == I
assert refine(exp(pi*I*2*(k + Rational(3, 4)))) == -I
assert exp(log(x)) == x
assert exp(2*log(x)) == x**2
assert exp(pi*log(x)) == x**pi
assert exp(17*log(x) + E*log(y)) == x**17 * y**E
assert exp(x*log(x)) != x**x
assert exp(sin(x)*log(x)) != x
assert exp(3*log(x) + oo*x) == exp(oo*x) * x**3
assert exp(4*log(x)*log(y) + 3*log(x)) == x**3 * exp(4*log(x)*log(y))
def test_pow2():
# powers of (-1)
assert refine((-1)**(x + y), Q.even(x)) == (-1)**y
assert refine((-1)**(x + y + z), Q.odd(x) & Q.odd(z)) == (-1)**y
assert refine((-1)**(x + y + 1), Q.odd(x)) == (-1)**y
assert refine((-1)**(x + y + 2), Q.odd(x)) == (-1)**(y + 1)
assert refine((-1)**(x + 3)) == (-1)**(x + 1)
def test_pow2():
# powers of (-1)
assert refine((-1)**(x + y), Q.even(x)) == (-1)**y
assert refine((-1)**(x + y + z), Q.odd(x) & Q.odd(z)) == (-1)**y
assert refine((-1)**(x + y + 1), Q.odd(x)) == (-1)**y
assert refine((-1)**(x + y + 2), Q.odd(x)) == (-1)**(y + 1)
assert refine((-1)**(x + 3)) == (-1)**(x + 1)
def test_atan2():
assert refine(atan2(y, x), Q.real(y) & Q.positive(x)) == atan(y / x)
assert refine(atan2(y, x), Q.negative(y) & Q.positive(x)) == atan(y / x)
assert refine(atan2(y, x),
Q.negative(y) & Q.negative(x)) == atan(y / x) - pi
assert refine(atan2(y, x),
Q.positive(y) & Q.negative(x)) == atan(y / x) + pi
def symbolic_stuff():
from sympy import Symbol, pi, sqrt, pprint, solve, Eq, solveset, refine
Kv = Symbol("Kv", real=True,
positive=True) # Kv measured in RPM per volt back_emf - Kv * V
Rm = Symbol("Rm", real=True, positive=True) # Winding Resistance
V = Symbol("V", real=True, positive=True)
I = Symbol("I", real=True, positive=True) # Peak Current
I0 = Symbol("I0", real=True, positive=True) # No load current
V0 = Symbol("V0", real=True, positive=True) # No load voltage
rpm2omega = pi / 30 # multiply RPM by this value to get angular frequency omega
Kv_SI = Kv * rpm2omega # Kv in rad/s per volt.
# Torque Constant
Kq = 1 / Kv_SI
# RPM at current I
RPM = Kv * (I - I0)
Q = Kq * (I - I0)
# RPM at voltage V and torque q_in
q_in = Symbol("q_in", real=True, positive=True)
rpm_in = Symbol("rpm_in", real=True, positive=True)
eqns = Eq(Q, q_in)
soln = solve(eqns, I, exclude=[I0])
pprint(eqns)
print(("RPM at torque Q: {}".format(RPM.subs(I, soln[0]))))
# Efficiency
eta = (V - I * Rm) * (I - I0) / (V * I)
print(("efficiency={}".format(eta)))
# Current at Max Efficiency
Imax = sqrt(V * I0 / Rm)
# Torque at max efficiency:
Qmax = Kq * (Imax - I0)
# RPM at max eff.
RPMmax = Kv * (V - Imax * Rm)
print("Current at Max Efficiency: {}".format(Imax))
print("RPM at Max Efficiency : {}".format(RPMmax))
print("Torque at Max Efficiency : {}".format(Qmax))
I_max = Symbol("I_max", real=True, positive=True)
eqns = Imax - I_max
pprint(eqns)
IOsoln = refine(solve(eqns, I0))
print("No-load-current : {}".format(IOsoln))
IOsoln = refine(solveset(eqns, I0))
print("No-load-current : {}".format(IOsoln))
def test_exp_infinity():
assert exp(I * y) != nan
assert refine(exp(I * oo)) is nan
assert refine(exp(-I * oo)) is nan
assert exp(y * I * oo) != nan
assert exp(zoo) is nan
x = Symbol('x', extended_real=True, finite=False)
assert exp(x).is_complex is None
def test_pow4():
assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1)
assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x
# powers of Abs
assert refine(Abs(x)**2, Q.real(x)) == x**2
assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3
assert refine(Abs(x)**2) == Abs(x)**2
def test_pow2():
assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1)
assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x
# powers of Abs
assert refine(Abs(x)**2, Q.real(x)) == x**2
assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3
assert refine(Abs(x)**2) == Abs(x)**2
def test_refine_issue_12724():
expr1 = refine(Abs(x * y), Q.positive(x))
expr2 = refine(Abs(x * y * z), Q.positive(x))
assert expr1 == x * Abs(y)
assert expr2 == x * Abs(y * z)
y1 = Symbol('y1', real = True)
expr3 = refine(Abs(x * y1**2 * z), Q.positive(x))
assert expr3 == x * y1**2 * Abs(z)
def test_matrixelement():
x = MatrixSymbol('x', 3, 3)
i = Symbol('i', positive = True)
j = Symbol('j', positive = True)
assert refine(x[0, 1], Q.symmetric(x)) == x[0, 1]
assert refine(x[1, 0], Q.symmetric(x)) == x[0, 1]
assert refine(x[i, j], Q.symmetric(x)) == x[j, i]
assert refine(x[j, i], Q.symmetric(x)) == x[j, i]
def test_refine_issue_12724():
expr1 = refine(Abs(x * y), Q.positive(x))
expr2 = refine(Abs(x * y * z), Q.positive(x))
assert expr1 == x * Abs(y)
assert expr2 == x * Abs(y * z)
y1 = Symbol('y1', real = True)
expr3 = refine(Abs(x * y1**2 * z), Q.positive(x))
assert expr3 == x * y1**2 * Abs(z)
def test_exp():
x = symbols('x')
assert refine(exp(pi * I * 2 * x), Assume(x, Q.integer)) == 1
assert refine(exp(pi * I * 2 * (x + Rational(1, 2))),
Assume(x, Q.integer)) == -1
assert refine(exp(pi * I * 2 * (x + Rational(1, 4))),
Assume(x, Q.integer)) == I
assert refine(exp(pi * I * 2 * (x + Rational(3, 4))),
Assume(x, Q.integer)) == -I
def test_complex():
assert refine(re(1/(x + I*y)), Q.real(x) & Q.real(y)) == \
x/(x**2 + y**2)
assert refine(im(1/(x + I*y)), Q.real(x) & Q.real(y)) == \
-y/(x**2 + y**2)
assert refine(re((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y)
& Q.real(z)) == w*y - x*z
assert refine(im((w + I*x) * (y + I*z)), Q.real(w) & Q.real(x) & Q.real(y)
& Q.real(z)) == w*z + x*y
def test_Abs():
x = Symbol('x', positive=True)
assert Abs(x) == x
assert 1 + Abs(x) == 1 + x
x = Symbol('x', negative=True)
assert Abs(x) == -x
assert 1 + Abs(x) == 1 - x
x = Symbol('x')
assert refine(Abs(x**2)) != x**2
x = Symbol('x', real=True)
assert refine(Abs(x**2)) == x**2
def test_Abs():
x = Symbol('x', positive=True)
assert Abs(x) == x
assert 1 + Abs(x) == 1 + x
x = Symbol('x', negative=True)
assert Abs(x) == -x
assert 1 + Abs(x) == 1 - x
x = Symbol('x')
assert refine(Abs(x**2)) != x**2
x = Symbol('x', real=True)
assert refine(Abs(x**2)) == x**2
def r_lambda(M):
_N = M[:-1, :-1]
nb_rows, nb_cols = _N.shape
hnm = _h(n, m)(_N).evalf()
knm = _k(n, m)(_N).evalf()
iknm = sp.refine(invert(knm), sp.Q.integer(k))
eN = sp.refine(sp.simplify(hnm) * iknm, sp.Q.integer(k))
return sp.Matrix(
sp.BlockMatrix(
[[eN, sp.zeros(nb_rows, 1)],
[sp.zeros(1, nb_cols),
sp.Matrix([sp.exp(M[-1, -1])])]]))
def set_weighted_error_model(model):
"""Encode error model with one epsilon and W as weight"""
stats, y, f = _preparations(model)
epsilons = model.random_variables.epsilons
expr = stats.find_assignment(y.name).expression
ssum = 0
q = sympy.Q.real(y) # Dummy predicate
for term in expr.args:
eps = [x for x in term.free_symbols if x.name in epsilons.names]
if len(eps) > 0:
eps = eps[0]
remaining = term / eps
ssum += remaining ** 2
for symb in remaining.free_symbols:
q &= sympy.Q.positive(symb)
w = sympy.sqrt(ssum)
w = sympy.refine(w, q)
for i, s in enumerate(stats):
if isinstance(s, Assignment) and s.symbol == y:
stats.insert(i, Assignment('W', w))
break
stats.reassign(y, f + sympy.Symbol('W') * sympy.Symbol(epsilons[0].name))
model.remove_unused_parameters_and_rvs()
return model
def calculate_absolute_uncertainty(
self,
*assumptions: List[AppliedPredicate],
refine: bool = False,
delta_char: str = '\\Delta ') -> 'Expression':
"""Calculate the absolute uncertainty in the expression (IB way), assuming all args given are independent.
:return: the absolute uncertainty of this expression
:rtype: Expression
>>> Expression([a], c * a).calculate_absolute_uncertainty(sympy.Q.positive(c), refine=True, delta_char='Δ')
f(Δa) = c*Δa
>>> Expression([a, b, c], a + b - c).calculate_absolute_uncertainty(refine=True, delta_char='Δ')
f(Δa, Δb, Δc) = Δa + Δb + Δc
"""
uncertainty_expr = sympy.Integer(0) # just in case
uncertainty_args = []
global_assumptions.add(*assumptions)
for var in self.args:
d_var = sympy.Symbol(delta_char + sympy.latex(var))
uncertainty_args.append(d_var)
uncertainty_expr += sympy.Abs(self.expr.diff(var)) * d_var
global_assumptions.add(sympy.Q.positive(var))
if refine:
uncertainty_expr = sympy.refine(uncertainty_expr)
global_assumptions.clear()
return Expression(uncertainty_args, uncertainty_expr)
def test_issue_8545():
from sympy import refine
eq = 1 - x - abs(1 - x)
ans = And(Lt(1, x), Lt(x, oo))
assert reduce_abs_inequality(eq, '<', x) == ans
eq = 1 - x - sqrt((1 - x)**2)
assert reduce_inequalities(refine(eq) < 0) == ans
def test_eval_refine():
class MockExpr(Expr):
def _eval_refine(self, assumptions):
return True
mock_obj = MockExpr()
assert refine(mock_obj)
def test_issue_8545():
from sympy import refine
eq = 1 - x - abs(1 - x)
ans = And(Lt(1, x), Lt(x, oo))
assert reduce_abs_inequality(eq, '<', x) == ans
eq = 1 - x - sqrt((1 - x)**2)
assert reduce_inequalities(refine(eq) < 0) == ans
def test_atan2():
assert refine(atan2(y, x), Q.real(y) & Q.positive(x)) == atan(y/x)
assert refine(atan2(y, x), Q.negative(y) & Q.positive(x)) == atan(y/x)
assert refine(atan2(y, x), Q.negative(y) & Q.negative(x)) == atan(y/x) - pi
assert refine(atan2(y, x), Q.positive(y) & Q.negative(x)) == atan(y/x) + pi
assert refine(atan2(y, x), Q.zero(y) & Q.negative(x)) == pi
assert refine(atan2(y, x), Q.positive(y) & Q.zero(x)) == pi/2
assert refine(atan2(y, x), Q.negative(y) & Q.zero(x)) == -pi/2
assert refine(atan2(y, x), Q.zero(y) & Q.zero(x)) == nan
def test_eval_refine():
from sympy.core.expr import Expr
class MockExpr(Expr):
def _eval_refine(self):
return True
mock_obj = MockExpr()
assert refine(mock_obj)
def test_eval_refine():
from sympy.core.expr import Expr
class MockExpr(Expr):
def _eval_refine(self, assumptions):
return True
mock_obj = MockExpr()
assert refine(mock_obj)
def test_im():
assert refine(im(x), Q.imaginary(x)) == -I*x
assert refine(im(x), Q.real(x)) is S.Zero
assert refine(im(x+y), Q.imaginary(x) & Q.imaginary(y)) == -I*x - I*y
assert refine(im(x+y), Q.real(x) & Q.imaginary(y)) == -I*y
assert refine(im(x*y), Q.imaginary(x) & Q.real(y)) == -I*x*y
assert refine(im(x*y), Q.imaginary(x) & Q.imaginary(y)) == 0
assert refine(im(1/x), Q.imaginary(x)) == -I/x
assert refine(im(x*y*z), Q.imaginary(x) & Q.imaginary(y)
& Q.imaginary(z)) == -I*x*y*z
def test_atan2():
assert atan2.nargs == FiniteSet(2)
assert atan2(0, 0) == S.NaN
assert atan2(0, 1) == 0
assert atan2(1, 1) == pi/4
assert atan2(1, 0) == pi/2
assert atan2(1, -1) == 3*pi/4
assert atan2(0, -1) == pi
assert atan2(-1, -1) == -3*pi/4
assert atan2(-1, 0) == -pi/2
assert atan2(-1, 1) == -pi/4
i = symbols('i', imaginary=True)
r = symbols('r', real=True)
eq = atan2(r, i)
ans = -I*log((i + I*r)/sqrt(i**2 + r**2))
reps = ((r, 2), (i, I))
assert eq.subs(reps) == ans.subs(reps)
x = Symbol('x', negative=True)
y = Symbol('y', negative=True)
assert atan2(y, x) == atan(y/x) - pi
y = Symbol('y', nonnegative=True)
assert atan2(y, x) == atan(y/x) + pi
y = Symbol('y')
assert atan2(y, x) == atan2(y, x, evaluate=False)
u = Symbol("u", positive=True)
assert atan2(0, u) == 0
u = Symbol("u", negative=True)
assert atan2(0, u) == pi
assert atan2(y, oo) == 0
assert atan2(y, -oo)== 2*pi*Heaviside(re(y)) - pi
assert atan2(y, x).rewrite(log) == -I*log((x + I*y)/sqrt(x**2 + y**2))
assert atan2(y, x).rewrite(atan) == 2*atan(y/(x + sqrt(x**2 + y**2)))
ex = atan2(y, x) - arg(x + I*y)
assert ex.subs({x:2, y:3}).rewrite(arg) == 0
assert ex.subs({x:2, y:3*I}).rewrite(arg) == -pi - I*log(sqrt(5)*I/5)
assert ex.subs({x:2*I, y:3}).rewrite(arg) == -pi/2 - I*log(sqrt(5)*I)
assert ex.subs({x:2*I, y:3*I}).rewrite(arg) == -pi + atan(2/S(3)) + atan(3/S(2))
i = symbols('i', imaginary=True)
r = symbols('r', real=True)
e = atan2(i, r)
rewrite = e.rewrite(arg)
reps = {i: I, r: -2}
assert rewrite == -I*log(abs(I*i + r)/sqrt(abs(i**2 + r**2))) + arg((I*i + r)/sqrt(i**2 + r**2))
assert refine((e - rewrite).subs(reps)).equals(0)
assert conjugate(atan2(x, y)) == atan2(conjugate(x), conjugate(y))
assert diff(atan2(y, x), x) == -y/(x**2 + y**2)
assert diff(atan2(y, x), y) == x/(x**2 + y**2)
assert simplify(diff(atan2(y, x).rewrite(log), x)) == -y/(x**2 + y**2)
assert simplify(diff(atan2(y, x).rewrite(log), y)) == x/(x**2 + y**2)
def test_issue_8514():
from sympy import simplify, refine
a, b, c, = symbols('a b c', positive=True)
t = symbols('t', positive=True)
ft = simplify(inverse_laplace_transform(1 / (a * s**2 + b * s + c), s, t))
assert ft == (
(exp(t * (exp(I * atan2(0, -4 * a * c + b**2) / 2) - exp(-I * atan2(
0, -4 * a * c + b**2) / 2)) * sqrt(refine(Abs(4 * a * c - b**2))) /
(4 * a)) * exp(t * cos(atan2(0, -4 * a * c + b**2) / 2) *
sqrt(refine(Abs(4 * a * c - b**2))) / a) +
I * sin(t * sin(atan2(0, -4 * a * c + b**2) / 2) *
sqrt(refine(Abs(4 * a * c - b**2))) /
(2 * a)) - cos(t * sin(atan2(0, -4 * a * c + b**2) / 2) *
sqrt(refine(Abs(4 * a * c - b**2))) /
(2 * a))) *
exp(-t * (b + cos(atan2(0, -4 * a * c + b**2) / 2) *
sqrt(refine(Abs(4 * a * c - b**2)))) /
(2 * a)) / sqrt(-4 * a * c + b**2))
def test_sign():
x = Symbol('x', real = True)
assert refine(sign(x), Q.positive(x)) == 1
assert refine(sign(x), Q.negative(x)) == -1
assert refine(sign(x), Q.zero(x)) == 0
assert refine(sign(x), True) == sign(x)
assert refine(sign(Abs(x)), Q.nonzero(x)) == 1
x = Symbol('x', imaginary=True)
assert refine(sign(x), Q.positive(im(x))) == S.ImaginaryUnit
assert refine(sign(x), Q.negative(im(x))) == -S.ImaginaryUnit
assert refine(sign(x), True) == sign(x)
x = Symbol('x', complex=True)
assert refine(sign(x), Q.zero(x)) == 0
def test_re():
assert refine(re(x), Q.real(x)) == x
assert refine(re(x), Q.imaginary(x)) is S.Zero
assert refine(re(x+y), Q.real(x) & Q.real(y)) == x + y
assert refine(re(x+y), Q.real(x) & Q.imaginary(y)) == x
assert refine(re(x*y), Q.real(x) & Q.real(y)) == x * y
assert refine(re(x*y), Q.real(x) & Q.imaginary(y)) == 0
assert refine(re(x*y*z), Q.real(x) & Q.real(y) & Q.real(z)) == x * y * z
def test_make_ode_01():
ode, params = _make_ode_01()
t, y, y0, k = params
result = dsolve(ode, y[1](t))
eq_assumption = sympy.Q.is_true(Ne(k[1], k[0]))
refined = refine(result, eq_assumption)
ignore = k + y0 + (t,)
int_const = [fs for fs in refined.free_symbols if fs not in ignore][0]
ref = int_const*exp(-k[1]*t) - exp(-k[0]*t)*k[0]*y0[0]/(k[0] - k[1])
assert (refined.rhs - ref).simplify() == 0
def test_exp_values():
if global_parameters.exp_is_pow:
assert type(exp(x)) is Pow
else:
assert type(exp(x)) is exp
k = Symbol('k', integer=True)
assert exp(nan) is nan
assert exp(oo) is oo
assert exp(-oo) == 0
assert exp(0) == 1
assert exp(1) == E
assert exp(-1 + x).as_base_exp() == (S.Exp1, x - 1)
assert exp(1 + x).as_base_exp() == (S.Exp1, x + 1)
assert exp(pi * I / 2) == I
assert exp(pi * I) == -1
assert exp(pi * I * Rational(3, 2)) == -I
assert exp(2 * pi * I) == 1
assert refine(exp(pi * I * 2 * k)) == 1
assert refine(exp(pi * I * 2 * (k + S.Half))) == -1
assert refine(exp(pi * I * 2 * (k + Rational(1, 4)))) == I
assert refine(exp(pi * I * 2 * (k + Rational(3, 4)))) == -I
assert exp(log(x)) == x
assert exp(2 * log(x)) == x**2
assert exp(pi * log(x)) == x**pi
assert exp(17 * log(x) + E * log(y)) == x**17 * y**E
assert exp(x * log(x)) != x**x
assert exp(sin(x) * log(x)) != x
assert exp(3 * log(x) + oo * x) == exp(oo * x) * x**3
assert exp(4 * log(x) * log(y) +
3 * log(x)) == x**3 * exp(4 * log(x) * log(y))
assert exp(-oo, evaluate=False).is_finite is True
assert exp(oo, evaluate=False).is_finite is False
def test_issue_8514():
from sympy import simplify, refine
a, b, c, = symbols("a b c", positive=True)
t = symbols("t", positive=True)
ft = simplify(inverse_laplace_transform(1 / (a * s ** 2 + b * s + c), s, t))
assert ft == (
(
exp(
t
* (exp(I * atan2(0, -4 * a * c + b ** 2) / 2) - exp(-I * atan2(0, -4 * a * c + b ** 2) / 2))
* sqrt(refine(Abs(4 * a * c - b ** 2)))
/ (4 * a)
)
* exp(t * cos(atan2(0, -4 * a * c + b ** 2) / 2) * sqrt(refine(Abs(4 * a * c - b ** 2))) / a)
+ I * sin(t * sin(atan2(0, -4 * a * c + b ** 2) / 2) * sqrt(refine(Abs(4 * a * c - b ** 2))) / (2 * a))
- cos(t * sin(atan2(0, -4 * a * c + b ** 2) / 2) * sqrt(refine(Abs(4 * a * c - b ** 2))) / (2 * a))
)
* exp(-t * (b + cos(atan2(0, -4 * a * c + b ** 2) / 2) * sqrt(refine(Abs(4 * a * c - b ** 2)))) / (2 * a))
/ sqrt(-4 * a * c + b ** 2)
)
def get_det_g(self, covariant=True):
"""Return determinant of covariant metric tensor"""
if self._det_g[covariant] is not None:
return self._det_g[covariant]
if covariant:
g = sp.Matrix(self.get_covariant_metric_tensor()).det()
else:
g = sp.Matrix(self.get_contravariant_metric_tensor()).det()
g = sp.refine(g, self._assumptions)
g = sp.simplify(g)
self._det_g[covariant] = g
return g
def Dx(test, x, k=1):
"""Return k'th order partial derivative in direction x
Parameters
----------
test: Expr or BasisFunction
x: int
axis to take derivative over
k: int
Number of derivatives
"""
assert isinstance(test, (Expr, BasisFunction))
if k > 1:
for _ in range(k):
test = Dx(test, x, 1)
return test
if isinstance(test, BasisFunction):
test = Expr(test)
test = copy.copy(test)
coors = test.function_space().coors
if coors.is_cartesian:
v = np.array(test.terms())
v[..., x] += k
test._terms = v.tolist()
else:
assert test.expr_rank(
) < 1, 'Cannot (yet) take derivative of tensor in curvilinear coordinates'
psi = coors.psi
v = copy.deepcopy(test.terms())
sc = copy.deepcopy(test.scales())
ind = copy.deepcopy(test.indices())
num_terms = test.num_terms()
for i in range(test.num_components()):
for j in range(num_terms[i]):
sc0 = sp.simplify(sp.diff(sc[i][j], psi[x], k))
sc0 = sp.refine(sc0, coors._assumptions)
if not sc0 == 0:
v[i].append(copy.deepcopy(v[i][j]))
sc[i].append(sc0)
ind[i].append(ind[i][j])
v[i][j][x] += k
test._terms = v
test._scales = sc
test._indices = ind
return test
def test_Abs():
assert refine(Abs(x), Q.positive(x)) == x
assert refine(1 + Abs(x), Q.positive(x)) == 1 + x
assert refine(Abs(x), Q.negative(x)) == -x
assert refine(1 + Abs(x), Q.negative(x)) == 1 - x
assert refine(Abs(x ** 2)) != x ** 2
assert refine(Abs(x ** 2), Q.real(x)) == x ** 2
def test_Abs():
assert refine(Abs(x), Q.positive(x)) == x
assert refine(1 + Abs(x), Q.positive(x)) == 1 + x
assert refine(Abs(x), Q.negative(x)) == -x
assert refine(1 + Abs(x), Q.negative(x)) == 1 - x
assert refine(Abs(x**2)) != x**2
assert refine(Abs(x**2), Q.real(x)) == x**2
def test_abs():
x = symbols('x')
assert refine(abs(x), Assume(x, Q.positive)) == x
assert refine(1+abs(x), Assume(x, Q.positive)) == 1+x
assert refine(abs(x), Assume(x, Q.negative)) == -x
assert refine(1+abs(x), Assume(x, Q.negative)) == 1-x
assert refine(abs(x**2)) != x**2
assert refine(abs(x**2), Assume(x, Q.real)) == x**2
def test_abs():
x = symbols('x')
assert refine(abs(x), Assume(x, Q.positive)) == x
assert refine(1 + abs(x), Assume(x, Q.positive)) == 1 + x
assert refine(abs(x), Assume(x, Q.negative)) == -x
assert refine(1 + abs(x), Assume(x, Q.negative)) == 1 - x
assert refine(abs(x**2)) != x**2
assert refine(abs(x**2), Assume(x, Q.real)) == x**2
def test_action_verbs():
assert nsimplify((1/(exp(3*pi*x/5)+1))) == (1/(exp(3*pi*x/5)+1)).nsimplify()
assert ratsimp(1/x + 1/y) == (1/x + 1/y).ratsimp()
assert trigsimp(log(x), deep=True) == (log(x)).trigsimp(deep = True)
assert radsimp(1/(2+sqrt(2))) == (1/(2+sqrt(2))).radsimp()
assert powsimp(x**y*x**z*y**z, combine='all') == (x**y*x**z*y**z).powsimp(combine='all')
assert simplify(x**y*x**z*y**z) == (x**y*x**z*y**z).simplify()
assert together(1/x + 1/y) == (1/x + 1/y).together()
assert separate((x*(y*z)**3)**2) == ((x*(y*z)**3)**2).separate()
assert collect(a*x**2 + b*x**2 + a*x - b*x + c, x) == (a*x**2 + b*x**2 + a*x - b*x + c).collect(x)
assert apart(y/(y+2)/(y+1), y) == (y/(y+2)/(y+1)).apart(y)
assert combsimp(y/(x+2)/(x+1)) == (y/(x+2)/(x+1)).combsimp()
assert factor(x**2+5*x+6) == (x**2+5*x+6).factor()
assert refine(sqrt(x**2)) == sqrt(x**2).refine()
assert cancel((x**2+5*x+6)/(x+2)) == ((x**2+5*x+6)/(x+2)).cancel()
def test_action_verbs():
assert nsimplify((1/(exp(3*pi*x/5)+1))) == (1/(exp(3*pi*x/5)+1)).nsimplify()
assert ratsimp(1/x + 1/y) == (1/x + 1/y).ratsimp()
assert trigsimp(log(x), deep=True) == (log(x)).trigsimp(deep = True)
assert radsimp(1/(2+sqrt(2))) == (1/(2+sqrt(2))).radsimp()
assert powsimp(x**y*x**z*y**z, combine='all') == (x**y*x**z*y**z).powsimp(combine='all')
assert simplify(x**y*x**z*y**z) == (x**y*x**z*y**z).simplify()
assert together(1/x + 1/y) == (1/x + 1/y).together()
assert separate((x*(y*z)**3)**2) == ((x*(y*z)**3)**2).separate()
assert collect(a*x**2 + b*x**2 + a*x - b*x + c, x) == (a*x**2 + b*x**2 + a*x - b*x + c).collect(x)
assert apart(y/(y+2)/(y+1), y) == (y/(y+2)/(y+1)).apart(y)
assert combsimp(y/(x+2)/(x+1)) == (y/(x+2)/(x+1)).combsimp()
assert factor(x**2+5*x+6) == (x**2+5*x+6).factor()
assert refine(sqrt(x**2)) == sqrt(x**2).refine()
assert cancel((x**2+5*x+6)/(x+2)) == ((x**2+5*x+6)/(x+2)).cancel()
def get_sqrt_det_g(self, covariant=True):
"""Return square root of determinant of covariant metric tensor"""
if self._sqrt_det_g[covariant] is not None:
return self._sqrt_det_g[covariant]
g = self.get_det_g(covariant)
sg = sp.refine(sp.simplify(sp.sqrt(g)), self._assumptions)
if isinstance(sg, numbers.Number):
if isinstance(sg, numbers.Real):
sg = np.float(sg)
elif isinstance(sg, numbers.Complex):
sg = np.complex(sg)
else:
raise NotImplementedError
self._sqrt_det_g[covariant] = sg
return sg
def test_make_integral_01():
integral, params = _make_integral_01()
intgr = integral.doit()
u0, k, l, t = params
# eq: k == l, neq: k != l
ref_eq = k * u0 * t
ref_neq = -k * u0 / (k - l) * (exp(t * (l - k)) - 1)
refined_eq = integral.subs({l: k}).doit()
assert (refined_eq - ref_eq).simplify() == 0
eq_assumption = sympy.Q.is_true(sympy.Ne(l, k))
refined_neq = sympy.refine(intgr, eq_assumption).simplify()
assert (refined_neq - ref_neq).simplify() == 0
def test_recursive():
from sympy import symbols, refine
a, b, c = symbols('a b c', positive=True)
r = exp(-(x - a)**2)*exp(-(x - b)**2)
e = integrate(r, (x, 0, oo), meijerg=True)
assert simplify(e.expand()) == (
sqrt(2)*sqrt(pi)*(
(erf(sqrt(2)*(a + b)/2) + 1)*exp(-a**2/2 + a*b - b**2/2))/4)
e = integrate(exp(-(x - a)**2)*exp(-(x - b)**2)*exp(c*x), (x, 0, oo), meijerg=True)
assert simplify(e) == (
sqrt(2)*sqrt(pi)*(erf(sqrt(2)*(2*a + 2*b + c)/4) + 1)*exp(-a**2 - b**2
+ (2*a + 2*b + c)**2/8)/4)
assert simplify(integrate(exp(-(x - a - b - c)**2), (x, 0, oo), meijerg=True)) == \
sqrt(pi)/2*(1 + erf(a + b + c))
assert simplify(refine(integrate(exp(-(x + a + b + c)**2), (x, 0, oo), meijerg=True))) == \
sqrt(pi)/2*(1 - erf(a + b + c))
def test_make_integral_01():
integral, params = _make_integral_01()
intgr = integral.doit()
u0, k, l, t = params
# eq: k == l, neq: k != l
ref_eq = k*u0*t
ref_neq = -k*u0/(k-l)*(exp(t*(l-k)) - 1)
refined_eq = integral.subs({l: k}).doit()
assert (refined_eq - ref_eq).simplify() == 0
eq_assumption = sympy.Q.is_true(sympy.Eq(l, k))
refined_neq = sympy.refine(intgr, ~eq_assumption).simplify()
print(refined_neq)
print(ref_neq)
assert (refined_neq - ref_neq).simplify() == 0
def test_func_args():
class MyClass(Expr):
# A class with nontrivial .func
def __init__(self, *args):
self.my_member = ""
@property
def func(self):
def my_func(*args):
obj = MyClass(*args)
obj.my_member = self.my_member
return obj
return my_func
x = MyClass()
x.my_member = "A very important value"
assert x.my_member == refine(x).my_member
def test_piecewise_fold_piecewise_in_cond():
p1 = Piecewise((cos(x), x < 0), (0, True))
p2 = Piecewise((0, Eq(p1, 0)), (p1 / Abs(p1), True))
p3 = piecewise_fold(p2)
assert(p2.subs(x, -pi/2) == 0.0)
assert(p2.subs(x, 1) == 0.0)
assert(refine(p2.subs(x, -pi/4)) == 1.0)
p4 = Piecewise((0, Eq(p1, 0)), (1,True))
assert(piecewise_fold(p4) == Piecewise(
(0, Or(And(Eq(cos(x), 0), x < 0), Not(x < 0))), (1, True)))
r1 = 1 < Piecewise((1, x < 1), (3, True))
assert(piecewise_fold(r1) == Not(x < 1))
p5 = Piecewise((1, x < 0), (3, True))
p6 = Piecewise((1, x < 1), (3, True))
p7 = piecewise_fold(Piecewise((1, p5 < p6), (0, True)))
assert(Piecewise((1, And(Not(x < 1), x < 0)), (0, True)))
def test_pow():
x, y, z = symbols('x y z')
assert refine((-1)**x, Assume(x, Q.even)) == 1
assert refine((-1)**x, Assume(x, Q.odd)) == -1
assert refine((-2)**x, Assume(x, Q.even)) == 2**x
# nested powers
assert refine(sqrt(x**2)) != Abs(x)
assert refine(sqrt(x**2), Assume(x, Q.complex)) != Abs(x)
assert refine(sqrt(x**2), Assume(x, Q.real)) == Abs(x)
assert refine(sqrt(x**2), Assume(x, Q.positive)) == x
assert refine((x**3)**(S(1)/3)) != x
assert refine((x**3)**(S(1)/3), Assume(x, Q.real)) != x
assert refine((x**3)**(S(1)/3), Assume(x, Q.positive)) == x
assert refine(sqrt(1/x), Assume(x, Q.real)) != 1/sqrt(x)
assert refine(sqrt(1/x), Assume(x, Q.positive)) == 1/sqrt(x)
# powers of (-1)
assert refine((-1)**(x+y), Assume(x, Q.even)) == (-1)**y
assert refine((-1)**(x+y+z), Assume(x, Q.odd)&Assume(z, Q.odd))==(-1)**y
assert refine((-1)**(x+y+1), Assume(x, Q.odd))==(-1)**y
assert refine((-1)**(x+y+2), Assume(x, Q.odd))==(-1)**(y+1)
assert refine((-1)**(x+3)) == (-1)**(x+1)
def test_exp():
assert refine(exp(pi * I * 2 * x), Q.integer(x)) == 1
assert refine(exp(pi * I * 2 * (x + Rational(1, 2))), Q.integer(x)) == -1
assert refine(exp(pi * I * 2 * (x + Rational(1, 4))), Q.integer(x)) == I
assert refine(exp(pi * I * 2 * (x + Rational(3, 4))), Q.integer(x)) == -I
def test_exp_infinity():
y = Symbol('y')
assert exp(I*y) != nan
assert refine(exp(I*oo)) == nan
assert refine(exp(-I*oo)) == nan
assert exp(y*I*oo) != nan
def test_pow():
assert refine((-1) ** x, Q.even(x)) == 1
assert refine((-1) ** x, Q.odd(x)) == -1
assert refine((-2) ** x, Q.even(x)) == 2 ** x
# nested powers
assert refine(sqrt(x ** 2)) != Abs(x)
assert refine(sqrt(x ** 2), Q.complex(x)) != Abs(x)
assert refine(sqrt(x ** 2), Q.real(x)) == Abs(x)
assert refine(sqrt(x ** 2), Q.positive(x)) == x
assert refine((x ** 3) ** (S(1) / 3)) != x
assert refine((x ** 3) ** (S(1) / 3), Q.real(x)) != x
assert refine((x ** 3) ** (S(1) / 3), Q.positive(x)) == x
assert refine(sqrt(1 / x), Q.real(x)) != 1 / sqrt(x)
assert refine(sqrt(1 / x), Q.positive(x)) == 1 / sqrt(x)
# powers of (-1)
assert refine((-1) ** (x + y), Q.even(x)) == (-1) ** y
assert refine((-1) ** (x + y + z), Q.odd(x) & Q.odd(z)) == (-1) ** y
assert refine((-1) ** (x + y + 1), Q.odd(x)) == (-1) ** y
assert refine((-1) ** (x + y + 2), Q.odd(x)) == (-1) ** (y + 1)
assert refine((-1) ** (x + 3)) == (-1) ** (x + 1)
assert refine((-1) ** ((-1) ** x / 2 - S.Half), Q.integer(x)) == (-1) ** x
assert refine((-1) ** ((-1) ** x / 2 + S.Half), Q.integer(x)) == (-1) ** (x + 1)
assert refine((-1) ** ((-1) ** x / 2 + 5 * S.Half), Q.integer(x)) == (-1) ** (x + 1)
assert refine((-1) ** ((-1) ** x / 2 - 7 * S.Half), Q.integer(x)) == (-1) ** (x + 1)
assert refine((-1) ** ((-1) ** x / 2 - 9 * S.Half), Q.integer(x)) == (-1) ** x
# powers of Abs
assert refine(Abs(x) ** 2, Q.real(x)) == x ** 2
assert refine(Abs(x) ** 3, Q.real(x)) == Abs(x) ** 3
assert refine(Abs(x) ** 2) == Abs(x) ** 2
def test_pow():
x = Symbol('x', even=True)
assert refine((-1)**x) == 1
x = Symbol('x', odd=True)
assert refine((-1)**x) == -1
x = Symbol('x', even=True)
assert refine((-2)**x) == 2**x
# nested powers
x = Symbol('x')
assert refine(sqrt(x**2)) != Abs(x)
x = Symbol('x', complex=True)
assert refine(sqrt(x**2)) != Abs(x)
x = Symbol('x', real=True)
assert refine(sqrt(x**2)) == Abs(x)
p = Symbol('p', positive=True)
assert refine(sqrt(p**2)) == p
x = Symbol('x')
assert refine((x**3)**(S(1)/3)) != x
x = Symbol('x', real=True)
assert refine((x**3)**(S(1)/3)) != x
x = Symbol('x', positive=True)
assert refine((x**3)**(S(1)/3)) == x
x = Symbol('x', real=True)
assert refine(sqrt(1/x)) != 1/sqrt(x)
x = Symbol('x', positive=True)
assert refine(sqrt(1/x)) == 1/sqrt(x)
# powers of (-1)
x = Symbol('x', even=True)
assert refine((-1)**(x + y), Q.even(x)) == (-1)**y
x = Symbol('x', odd=True)
z = Symbol('z', odd=True)
assert refine((-1)**(x + y + z), Q.odd(x) & Q.odd(z)) == (-1)**y
assert refine((-1)**(x + y + 1), Q.odd(x)) == (-1)**y
assert refine((-1)**(x + y + 2), Q.odd(x)) == (-1)**(y + 1)
x = Symbol('x')
assert refine((-1)**(x + 3)) == (-1)**(x + 1)
x = Symbol('x', integer=True)
assert refine((-1)**((-1)**x/2 - S.Half), Q.integer(x)) == (-1)**x
assert refine((-1)**((-1)**x/2 + S.Half), Q.integer(x)) == (-1)**(x + 1)
assert refine((-1)**((-1)**x/2 + 5*S.Half), Q.integer(x)) == (-1)**(x + 1)
assert refine((-1)**((-1)**x/2 - 7*S.Half), Q.integer(x)) == (-1)**(x + 1)
assert refine((-1)**((-1)**x/2 - 9*S.Half), Q.integer(x)) == (-1)**x
# powers of Abs
x = Symbol('x', real=True)
assert refine(Abs(x)**2, Q.real(x)) == x**2
assert refine(Abs(x)**3, Q.real(x)) == Abs(x)**3
x = Symbol('x')
assert refine(Abs(x)**2) == Abs(x)**2
def test_Piecewise():
assert refine(Piecewise((1, x < 0), (3, True)), Q.is_true(x < 0)) == 1
assert refine(Piecewise((1, x < 0), (3, True)), ~Q.is_true(x < 0)) == 3
assert refine(Piecewise((1, x < 0), (3, True)), Q.is_true(y < 0)) == \
Piecewise((1, x < 0), (3, True))
assert refine(Piecewise((1, x > 0), (3, True)), Q.is_true(x > 0)) == 1
assert refine(Piecewise((1, x > 0), (3, True)), ~Q.is_true(x > 0)) == 3
assert refine(Piecewise((1, x > 0), (3, True)), Q.is_true(y > 0)) == \
Piecewise((1, x > 0), (3, True))
assert refine(Piecewise((1, x <= 0), (3, True)), Q.is_true(x <= 0)) == 1
assert refine(Piecewise((1, x <= 0), (3, True)), ~Q.is_true(x <= 0)) == 3
assert refine(Piecewise((1, x <= 0), (3, True)), Q.is_true(y <= 0)) == \
Piecewise((1, x <= 0), (3, True))
assert refine(Piecewise((1, x >= 0), (3, True)), Q.is_true(x >= 0)) == 1
assert refine(Piecewise((1, x >= 0), (3, True)), ~Q.is_true(x >= 0)) == 3
assert refine(Piecewise((1, x >= 0), (3, True)), Q.is_true(y >= 0)) == \
Piecewise((1, x >= 0), (3, True))
assert refine(Piecewise((1, Eq(x, 0)), (3, True)), Q.is_true(Eq(x, 0)))\
== 1
assert refine(Piecewise((1, Eq(x, 0)), (3, True)), ~Q.is_true(Eq(x, 0)))\
== 3
assert refine(Piecewise((1, Eq(x, 0)), (3, True)), Q.is_true(Eq(y, 0)))\
== Piecewise((1, Eq(x, 0)), (3, True))
assert refine(Piecewise((1, Ne(x, 0)), (3, True)), Q.is_true(Ne(x, 0)))\
== 1
assert refine(Piecewise((1, Ne(x, 0)), (3, True)), ~Q.is_true(Ne(x, 0)))\
== 3
assert refine(Piecewise((1, Ne(x, 0)), (3, True)), Q.is_true(Ne(y, 0)))\
== Piecewise((1, Ne(x, 0)), (3, True))
def test_Relational():
assert not refine(x < 0, ~Q.is_true(x < 0))
assert refine(x < 0, Q.is_true(x < 0))
assert refine(x < 0, Q.is_true(y < 0)) == (x < 0)
assert not refine(x <= 0, ~Q.is_true(x <= 0))
assert refine(x <= 0, Q.is_true(x <= 0))
assert refine(x <= 0, Q.is_true(y <= 0)) == (x <= 0)
assert not refine(x > 0, ~Q.is_true(x > 0))
assert refine(x > 0, Q.is_true(x > 0))
assert refine(x > 0, Q.is_true(y > 0)) == (x > 0)
assert not refine(x >= 0, ~Q.is_true(x >= 0))
assert refine(x >= 0, Q.is_true(x >= 0))
assert refine(x >= 0, Q.is_true(y >= 0)) == (x >= 0)
assert not refine(Eq(x, 0), ~Q.is_true(Eq(x, 0)))
assert refine(Eq(x, 0), Q.is_true(Eq(x, 0)))
assert refine(Eq(x, 0), Q.is_true(Eq(y, 0))) == Eq(x, 0)
assert not refine(Ne(x, 0), ~Q.is_true(Ne(x, 0)))
assert refine(Ne(x, 0), Q.is_true(Ne(x, 0)))
assert refine(Ne(x, 0), Q.is_true(Ne(y, 0))) == (Ne(x, 0))
def test_exp():
x = Symbol('x', integer=True)
assert refine(exp(pi*I*2*x)) == 1
assert refine(exp(pi*I*2*(x + Rational(1, 2)))) == -1
assert refine(exp(pi*I*2*(x + Rational(1, 4)))) == I
assert refine(exp(pi*I*2*(x + Rational(3, 4)))) == -I
def test_refine():
assert refine(C.T, Q.symmetric(C)) == C
def test_exp():
x = symbols('x')
assert refine(exp(pi*I*2*x), Assume(x, Q.integer)) == 1
assert refine(exp(pi*I*2*(x+Rational(1,2))), Assume(x, Q.integer)) == -1
assert refine(exp(pi*I*2*(x+Rational(1,4))), Assume(x, Q.integer)) == I
assert refine(exp(pi*I*2*(x+Rational(3,4))), Assume(x, Q.integer)) == -I
def test_transpose1x1():
m = MatrixSymbol('m', 1, 1)
assert m == refine(m.T)
assert m == refine(m.T.T)
def test_pow():
x, y = symbols('x y')
assert refine((-1)**x, Assume(x, Q.even)) == 1
assert refine((-1)**x, Assume(x, Q.odd)) == -1
assert refine((-2)**x, Assume(x, Q.even)) == 2**x
# nested powers
assert refine(sqrt(x**2)) != abs(x)
assert refine(sqrt(x**2), Assume(x, Q.complex)) != abs(x)
assert refine(sqrt(x**2), Assume(x, Q.real)) == abs(x)
assert refine(sqrt(x**2), Assume(x, Q.positive)) == x
assert refine((x**3)**(S(1)/3)) != x
assert refine((x**3)**(S(1)/3), Assume(x, Q.real)) != x
assert refine((x**3)**(S(1)/3), Assume(x, Q.positive)) == x
assert refine(sqrt(1/x), Assume(x, Q.real)) != 1/sqrt(x)
assert refine(sqrt(1/x), Assume(x, Q.positive)) == 1/sqrt(x)
def test_refine():
assert refine(C*C.T*D, Q.orthogonal(C)).doit() == D
kC = k*C
assert refine(kC*C.T, Q.orthogonal(C)).doit() == k*Identity(n)
assert refine(kC* kC.T, Q.orthogonal(C)).doit() == (k**2)*Identity(n)
