def test_cosine_transform():
f = Function("f")
# Test unevaluated form
assert cosine_transform(f(t), t, w) == CosineTransform(f(t), t, w)
assert inverse_cosine_transform(
f(w), w, t) == InverseCosineTransform(f(w), w, t)
assert cosine_transform(1/sqrt(t), t, w) == 1/sqrt(w)
assert inverse_cosine_transform(1/sqrt(w), w, t) == 1/sqrt(t)
assert cosine_transform(1/(
a**2 + t**2), t, w) == sqrt(2)*sqrt(pi)*exp(-a*w)/(2*a)
assert cosine_transform(t**(
-a), t, w) == 2**(-a + Rational(1, 2))*w**(a - 1)*gamma((-a + 1)/2)/gamma(a/2)
assert inverse_cosine_transform(2**(-a +
Rational(1, 2))*w**(a - 1)*gamma(-a/2 + Rational(1, 2))/gamma(a/2), w, t) == t**(-a)
assert cosine_transform(
exp(-a*t), t, w) == sqrt(2)*a/(sqrt(pi)*(a**2 + w**2))
assert inverse_cosine_transform(
sqrt(2)*a/(sqrt(pi)*(a**2 + w**2)), w, t) == exp(-a*t)
assert cosine_transform(exp(-a*sqrt(t))*cos(a*sqrt(
t)), t, w) == a*exp(-a**2/(2*w))/(2*w**Rational(3, 2))
assert cosine_transform(1/(a + t), t, w) == sqrt(2)*(
(-2*Si(a*w) + pi)*sin(a*w)/2 - cos(a*w)*Ci(a*w))/sqrt(pi)
assert inverse_cosine_transform(sqrt(2)*meijerg(((Rational(1, 2), 0), ()), (
(Rational(1, 2), 0, 0), (Rational(1, 2),)), a**2*w**2/4)/(2*pi), w, t) == 1/(a + t)
assert cosine_transform(1/sqrt(a**2 + t**2), t, w) == sqrt(2)*meijerg(
((Rational(1, 2),), ()), ((0, 0), (Rational(1, 2),)), a**2*w**2/4)/(2*sqrt(pi))
assert inverse_cosine_transform(sqrt(2)*meijerg(((Rational(1, 2),), ()), ((0, 0), (Rational(1, 2),)), a**2*w**2/4)/(2*sqrt(pi)), w, t) == 1/(a*sqrt(1 + t**2/a**2))
def test_arithmetic_sums():
assert summation(1, (n, a, b)) == b - a + 1
assert Sum(nan, (n, a, b)) is nan
assert Sum(x, (n, a, a)).doit() == x
assert Sum(x, (x, a, a)).doit() == a
assert Sum(x, (n, 1, a)).doit() == a*x
lo, hi = 1, 2
s1 = Sum(n, (n, lo, hi))
s2 = Sum(n, (n, hi, lo))
assert s1 != s2
assert s1.doit() == 3 and s2.doit() == 0
lo, hi = x, x + 1
s1 = Sum(n, (n, lo, hi))
s2 = Sum(n, (n, hi, lo))
assert s1 != s2
assert s1.doit() == 2*x + 1 and s2.doit() == 0
assert Sum(Integral(x, (x, 1, y)) + x, (x, 1, 2)).doit() == \
y**2 + 2
assert summation(1, (n, 1, 10)) == 10
assert summation(2*n, (n, 0, 10**10)) == 100000000010000000000
assert summation(4*n*m, (n, a, 1), (m, 1, d)).expand() == \
2*d + 2*d**2 + a*d + a*d**2 - d*a**2 - a**2*d**2
assert summation(cos(n), (n, -2, 1)) == cos(-2) + cos(-1) + cos(0) + cos(1)
assert summation(cos(n), (n, x, x + 2)) == cos(x) + cos(x + 1) + cos(x + 2)
assert isinstance(summation(cos(n), (n, x, x + Rational(1, 2))), Sum)
assert summation(k, (k, 0, oo)) == oo
def test_sqrtdenest2():
assert sqrtdenest(sqrt(16 - 2*r29 + 2*sqrt(55 - 10*r29))) == \
r5 + sqrt(11 - 2*r29)
e = sqrt(-r5 + sqrt(-2*r29 + 2*sqrt(-10*r29 + 55) + 16))
assert sqrtdenest(e) == root(-2*r29 + 11, 4)
r = sqrt(1 + r7)
assert sqrtdenest(sqrt(1 + r)) == sqrt(1 + r)
e = sqrt(((1 + sqrt(1 + 2*sqrt(3 + r2 + r5)))**2).expand())
assert sqrtdenest(e) == 1 + sqrt(1 + 2*sqrt(r2 + r5 + 3))
assert sqrtdenest(sqrt(5*r3 + 6*r2)) == sqrt(2)*root(3, 4) + root(27, 4)
assert sqrtdenest(sqrt(((1 + r5 + sqrt(1 + r3))**2).expand())) == \
1 + r5 + sqrt(1 + r3)
assert sqrtdenest(sqrt(((1 + r5 + r7 + sqrt(1 + r3))**2).expand())) == \
1 + sqrt(1 + r3) + r5 + r7
e = sqrt(((1 + cos(2) + cos(3) + sqrt(1 + r3))**2).expand())
assert sqrtdenest(e) == cos(3) + cos(2) + 1 + sqrt(1 + r3)
e = sqrt(-2*r10 + 2*r2*sqrt(-2*r10 + 11) + 14)
assert sqrtdenest(e) == sqrt(-2*r10 - 2*r2 + 4*r5 + 14)
# check that the result is not more complicated than the input
z = sqrt(-2*r29 + cos(2) + 2*sqrt(-10*r29 + 55) + 16)
assert sqrtdenest(z) == z
assert sqrtdenest(sqrt(r6 + sqrt(15))) == sqrt(r6 + sqrt(15))
z = sqrt(15 - 2*sqrt(31) + 2*sqrt(55 - 10*r29))
assert sqrtdenest(z) == z
def plot_and_save(name):
# implicit plot tests
plot_implicit(Eq(y, cos(x)), (x, -5, 5), (y, -2, 2), show=False).save(tmp_file(name))
plot_implicit(Eq(y**2, x**3 - x), (x, -5, 5),
(y, -4, 4), show=False).save(tmp_file(name))
plot_implicit(y > 1 / x, (x, -5, 5),
(y, -2, 2), show=False).save(tmp_file(name))
plot_implicit(y < 1 / tan(x), (x, -5, 5),
(y, -2, 2), show=False).save(tmp_file(name))
plot_implicit(y >= 2 * sin(x) * cos(x), (x, -5, 5),
(y, -2, 2), show=False).save(tmp_file(name))
plot_implicit(y <= x**2, (x, -3, 3),
(y, -1, 5), show=False).save(tmp_file(name))
plot_implicit(Or(And(x < y, x > y**2), sin(y) > x),
show=False).save(tmp_file(name))
plot_implicit(Or(And(x < y, x > y**2), sin(y)),
show=False).save(tmp_file(name))
plot_implicit(Or(x < y, sin(x) >= y), show=False).save(tmp_file(name))
# Test all input args for plot_implicit
plot_implicit(Eq(y**2, x**3 - x), show=False).save(tmp_file(name))
plot_implicit(Eq(y**2, x**3 - x), adaptive=False, show=False).save(tmp_file(name))
plot_implicit(Eq(y**2, x**3 - x), adaptive=False, points=500, show=False).save(tmp_file(name))
plot_implicit(y > x, (x, -5, 5), show=False).save(tmp_file(name))
plot_implicit(And(y > exp(x), y > x + 2), show=False).save(tmp_file(name))
plot_implicit(Or(y > x, y > -x), show=False).save(tmp_file(name))
plot_implicit(x**2 - 1, (x, -5, 5), show=False).save(tmp_file(name))
plot_implicit(x**2 - 1, show=False).save(tmp_file(name))
plot_implicit(y > x, depth=-5, show=False).save(tmp_file(name))
plot_implicit(y > x, depth=5, show=False).save(tmp_file(name))
plot_implicit(y > cos(x), adaptive=False, show=False).save(tmp_file(name))
plot_implicit(y < cos(x), adaptive=False, show=False).save(tmp_file(name))
plot_implicit(y - cos(pi / x), show=False).save(tmp_file(name))
pytest.raises(ValueError, lambda: plot_implicit(y > x, (x, -1, 1, 2)))
def test_matrices():
M = Matrix(2, 2, lambda i, j: (i + j + 1)*sin((i + j + 1)*x))
assert integrate(M, x) == Matrix([
[-cos(x), -cos(2*x)],
[-cos(2*x), -cos(3*x)],
])
def test_epath_apply():
expr = [((x, 1, t), 2), ((3, y, 4), z)]
def func(expr):
return expr**2
assert epath("/*", expr, list) == [[(x, 1, t), 2], [(3, y, 4), z]]
assert epath("/*/[0]", expr, list) == [([x, 1, t], 2), ([3, y, 4], z)]
assert epath("/*/[1]", expr, func) == [((x, 1, t), 4), ((3, y, 4), z**2)]
assert epath("/*/[2]", expr, list) == expr
assert epath("/*/[0]/int", expr, func) == [((x, 1, t), 2), ((9, y, 16), z)]
assert epath("/*/[0]/Symbol", expr, func) == [((x**2, 1, t**2), 2),
((3, y**2, 4), z)]
assert epath(
"/*/[0]/int[1:]", expr, func) == [((x, 1, t), 2), ((3, y, 16), z)]
assert epath("/*/[0]/Symbol[1:]", expr, func) == [((x, 1, t**2),
2), ((3, y**2, 4), z)]
assert epath("/Symbol", x + y + z + 1, func) == x**2 + y**2 + z**2 + 1
assert epath("/*/*/Symbol", t + sin(x + 1) + cos(x + y + E), func) == \
t + sin(x**2 + 1) + cos(x**2 + y**2 + E)
assert epath("/*/*/Symbol", t*sin(x + 1)*cos(x + y + E), func) == \
t*sin(x**2 + 1)*cos(x**2 + y**2 + E)
assert epath("/*/*/Symbol", [((x, 1), 2), ((3, y), z)], func) == \
[((x**2, 1), 2), ((3, y**2), z)]
def test_trigsimp_groebner():
c = cos(x)
s = sin(x)
ex = (4*s*c + 12*s + 5*c**3 + 21*c**2 + 23*c + 15)/(
-s*c**2 + 2*s*c + 15*s + 7*c**3 + 31*c**2 + 37*c + 21)
resnum = (5*s - 5*c + 1)
resdenom = (8*s - 6*c)
results = [resnum/resdenom, (-resnum)/(-resdenom)]
assert trigsimp_groebner(ex) in results
assert trigsimp_groebner(s/c, hints=[tan]) == tan(x)
assert trigsimp((-s + 1)/c + c/(-s + 1),
method='groebner') == 2/c
assert trigsimp((-s + 1)/c + c/(-s + 1),
method='groebner', polynomial=True) == 2/c
# Test quick=False works
assert trigsimp_groebner(ex, hints=[2]) in results
# test "I"
assert trigsimp_groebner(sin(I*x)/cos(I*x), hints=[tanh]) == I*tanh(x)
# test hyperbolic / sums
assert trigsimp_groebner((tanh(x)+tanh(y))/(1+tanh(x)*tanh(y)),
hints=[(tanh, x, y)]) == tanh(x + y)
# issue sympy/sympy#11062
trigsimp_groebner(csc(x) * sin(x)) # not raises
def test_nfloat():
x = Symbol("x")
eq = x**Rational(4, 3) + 4*cbrt(x)/3
assert _aresame(nfloat(eq), x**Rational(4, 3) + (4.0/3)*cbrt(x))
assert _aresame(nfloat(eq, exponent=True), x**(4.0/3) + (4.0/3)*x**(1.0/3))
eq = x**Rational(4, 3) + 4*x**(x/3)/3
assert _aresame(nfloat(eq), x**Rational(4, 3) + (4.0/3)*x**(x/3))
big = 12345678901234567890
# specify precision to match value used in nfloat
Float_big = Float(big, 15)
assert _aresame(nfloat(big), Float_big)
assert _aresame(nfloat(big*x), Float_big*x)
assert _aresame(nfloat(x**big, exponent=True), x**Float_big)
assert nfloat({x: sqrt(2)}) == {x: nfloat(sqrt(2))}
assert nfloat({sqrt(2): x}) == {sqrt(2): x}
assert nfloat(cos(x + sqrt(2))) == cos(x + nfloat(sqrt(2)))
# issue sympy/sympy#6342
lamda = Symbol('lamda')
f = x*lamda + lamda**3*(x/2 + Rational(1, 2)) + lamda**2 + Rational(1, 4)
assert not any(a[lamda].free_symbols
for a in solve(f.subs({x: -0.139})))
# issue sympy/sympy#6632
assert nfloat(-100000*sqrt(2500000001) + 5000000001) == \
9.99999999800000e-11
# issue sympy/sympy#7122
eq = cos(3*x**4 + y)*RootOf(x**5 + 3*x**3 + 1, 0)
assert str(nfloat(eq, exponent=False, n=1)) == '-0.7*cos(3.0*x**4 + y)'
def test_rootcomplex():
R = Rational
assert ((+1 + I)**R(1, 2)).expand(
complex=True) == 2**R(1, 4)*cos( pi/8) + 2**R(1, 4)*sin( pi/8)*I
assert ((-1 - I)**R(1, 2)).expand(
complex=True) == 2**R(1, 4)*cos(3*pi/8) - 2**R(1, 4)*sin(3*pi/8)*I
assert (sqrt(-10)*I).as_real_imag() == (-sqrt(10), 0)
def test_ode_solutions():
# only a few examples here, the rest will be tested in the actual dsolve tests
assert constant_renumber(constantsimp(C1*exp(2*x) + exp(x)*(C2 + C3), [C1, C2, C3]), 'C', 1, 3) == \
constant_renumber((C1*exp(x) + C2*exp(2*x)), 'C', 1, 2)
assert constant_renumber(
constantsimp(Eq(f(x), I*C1*sinh(x/3) + C2*cosh(x/3)), [C1, C2]),
'C', 1, 2) == constant_renumber(Eq(f(x), C1*sinh(x/3) + C2*cosh(x/3)), 'C', 1, 2)
assert constant_renumber(constantsimp(Eq(f(x), acos((-C1)/cos(x))), [C1]), 'C', 1, 1) == \
Eq(f(x), acos(C1/cos(x)))
assert constant_renumber(
constantsimp(Eq(log(f(x)/C1) + 2*exp(x/f(x)), 0), [C1]),
'C', 1, 1) == Eq(log(C1*f(x)) + 2*exp(x/f(x)), 0)
assert constant_renumber(constantsimp(Eq(log(x*sqrt(2)*sqrt(1/x)*sqrt(f(x))
/ C1) + x**2/(2*f(x)**2), 0), [C1]), 'C', 1, 1) == \
Eq(log(C1*sqrt(x)*sqrt(f(x))) + x**2/(2*f(x)**2), 0)
assert constant_renumber(constantsimp(Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(x/C1) -
cos(f(x)/x)*exp(-f(x)/x)/2, 0), [C1]), 'C', 1, 1) == \
Eq(-exp(-f(x)/x)*sin(f(x)/x)/2 + log(C1*x) - cos(f(x)/x) *
exp(-f(x)/x)/2, 0)
u2 = Symbol('u2')
_a = Symbol('_a')
assert constant_renumber(constantsimp(Eq(-Integral(-1/(sqrt(1 - u2**2)*u2),
(u2, _a, x/f(x))) + log(f(x)/C1), 0), [C1]), 'C', 1, 1) == \
Eq(-Integral(-1/(u2*sqrt(1 - u2**2)), (u2, _a, x/f(x))) +
log(C1*f(x)), 0)
assert [constantsimp(i, [C1]) for i in [Eq(f(x), sqrt(-C1*x + x**2)), Eq(f(x), -sqrt(-C1*x + x**2))]] == \
[Eq(f(x), sqrt(x*(C1 + x))), Eq(f(x), -sqrt(x*(C1 + x)))]
def test_sympyissue_3623():
assert integrate(cos((n + 1)*x), x) == Piecewise(
(x, Eq(n + 1, 0)), (sin((n + 1)*x)/(n + 1), True))
assert integrate(cos((n - 1)*x), x) == Piecewise(
(x, Eq(n - 1, 0)), (sin((n - 1)*x)/(n - 1), True))
assert integrate(cos((n + 1)*x) + cos((n - 1)*x), x) == \
Piecewise((x, Eq(n + 1, 0)), (sin((n + 1)*x)/(n + 1), True)) + \
Piecewise((x, Eq(n - 1, 0)), (sin((n - 1)*x)/(n - 1), True))
def test__TR56():
def h(x):
return 1 - x
assert T(sin(x)**3, sin, cos, h, 4, False) == sin(x)**3
assert T(sin(x)**10, sin, cos, h, 4, False) == sin(x)**10
assert T(sin(x)**6, sin, cos, h, 6, False) == (-cos(x)**2 + 1)**3
assert T(sin(x)**6, sin, cos, h, 6, True) == sin(x)**6
assert T(sin(x)**8, sin, cos, h, 10, True) == (-cos(x)**2 + 1)**4
def test_f_expand_complex():
x = Symbol('x', extended_real=True)
assert f(x).expand(complex=True) == I*im(f(x)) + re(f(x))
assert exp(x).expand(complex=True) == exp(x)
assert exp(I*x).expand(complex=True) == cos(x) + I*sin(x)
assert exp(z).expand(complex=True) == cos(im(z))*exp(re(z)) + \
I*sin(im(z))*exp(re(z))
def test_Subs():
assert Subs(x, (x, 0)) == Subs(y, (y, 0))
assert Subs(x, (x, 0)).subs({x: 1}) == Subs(x, (x, 0))
assert Subs(y, (x, 0)).subs({y: 1}) == Subs(1, (x, 0))
assert Subs(f(x), (x, 0)).doit() == f(0)
assert Subs(f(x**2), (x**2, 0)).doit() == f(0)
assert Subs(f(x, y, z), (x, 0), (y, 1), (z, 1)) != \
Subs(f(x, y, z), (x, 0), (y, 0), (z, 1))
assert Subs(f(x, y), (x, 0), (y, 1), (z, 1)) == \
Subs(f(x, y), (x, 0), (y, 1), (z, 2))
assert Subs(f(x, y), (x, 0), (y, 1), (z, 1)) != \
Subs(f(x, y) + z, (x, 0), (y, 1), (z, 0))
assert Subs(f(x, y), (x, 0), (y, 1)).doit() == f(0, 1)
assert Subs(Subs(f(x, y), (x, 0)), (y, 1)).doit() == f(0, 1)
pytest.raises(ValueError, lambda: Subs(f(x, y), x))
pytest.raises(ValueError, lambda: Subs(f(x, y), (x, 0), (x, 0), (y, 1)))
assert len(Subs(f(x, y), (x, 0), (y, 1)).variables) == 2
assert Subs(f(x, y), (x, 0), (y, 1)).point == Tuple(0, 1)
assert Subs(f(x), (x, 0)) == Subs(f(y), (y, 0))
assert Subs(f(x, y), (x, 0), (y, 1)) == Subs(f(x, y), (y, 1), (x, 0))
assert Subs(f(x)*y, (x, 0), (y, 1)) == Subs(f(y)*x, (y, 0), (x, 1))
assert Subs(f(x)*y, (x, 1), (y, 1)) == Subs(f(y)*x, (x, 1), (y, 1))
assert Subs(f(x), (x, 0)).subs({x: 1}).doit() == f(0)
assert Subs(f(x), (x, y)).subs({y: 0}) == Subs(f(x), (x, 0))
assert Subs(y*f(x), (x, y)).subs({y: 2}) == Subs(2*f(x), (x, 2))
assert (2 * Subs(f(x), (x, 0))).subs({Subs(f(x), (x, 0)): y}) == 2*y
assert Subs(f(x), (x, 0)).free_symbols == set()
assert Subs(f(x, y), (x, z)).free_symbols == {y, z}
assert Subs(f(x).diff(x), (x, 0)).doit(), Subs(f(x).diff(x), (x, 0))
assert Subs(1 + f(x).diff(x), (x, 0)).doit(), 1 + Subs(f(x).diff(x), (x, 0))
assert Subs(y*f(x, y).diff(x), (x, 0), (y, 2)).doit() == \
2*Subs(Derivative(f(x, 2), x), (x, 0))
assert Subs(y**2*f(x), (x, 0)).diff(y) == 2*y*f(0)
e = Subs(y**2*f(x), (x, y))
assert e.diff(y) == e.doit().diff(y) == y**2*Derivative(f(y), y) + 2*y*f(y)
assert Subs(f(x), (x, 0)) + Subs(f(x), (x, 0)) == 2*Subs(f(x), (x, 0))
e1 = Subs(z*f(x), (x, 1))
e2 = Subs(z*f(y), (y, 1))
assert e1 + e2 == 2*e1
assert e1.__hash__() == e2.__hash__()
assert Subs(z*f(x + 1), (x, 1)) not in (e1, e2)
assert Derivative(f(x), x).subs({x: g(x)}) == Derivative(f(g(x)), g(x))
assert Derivative(f(x), x).subs({x: x + y}) == Subs(Derivative(f(x), x),
(x, x + y))
assert Subs(f(x)*cos(y) + z, (x, 0), (y, pi/3)).evalf(2, strict=False) == \
Subs(f(x)*cos(y) + z, (x, 0), (y, pi/3)).evalf(2, strict=False) == \
z + Rational('1/2').evalf(2)*f(0)
assert f(x).diff(x).subs({x: 0}).subs({x: y}) == f(x).diff(x).subs({x: 0})
assert (x*f(x).diff(x).subs({x: 0})).subs({x: y}) == y*f(x).diff(x).subs({x: 0})
def test_ceiling_requires_robust_assumptions():
assert limit(ceiling(sin(x)), x, 0, "+") == 1
assert limit(ceiling(sin(x)), x, 0, "-") == 0
assert limit(ceiling(cos(x)), x, 0, "+") == 1
assert limit(ceiling(cos(x)), x, 0, "-") == 1
assert limit(ceiling(5 + sin(x)), x, 0, "+") == 6
assert limit(ceiling(5 + sin(x)), x, 0, "-") == 5
assert limit(ceiling(5 + cos(x)), x, 0, "+") == 6
assert limit(ceiling(5 + cos(x)), x, 0, "-") == 6
def test_TR3():
assert TR3(cos(y - x*(y - x))) == cos(x*(x - y) + y)
assert cos(pi/2 + x) == -sin(x)
assert cos(30*pi/2 + x) == -cos(x)
for f in (cos, sin, tan, cot, csc, sec):
i = f(3*pi/7)
j = TR3(i)
assert verify_numerically(i, j) and i.func != j.func
def test_basic1():
assert limit(x, x, oo) == oo
assert limit(x, x, -oo) == -oo
assert limit(-x, x, oo) == -oo
assert limit(x**2, x, -oo) == oo
assert limit(-x**2, x, oo) == -oo
assert limit(x*log(x), x, 0, dir="+") == 0
assert limit(1/x, x, oo) == 0
assert limit(exp(x), x, oo) == oo
assert limit(-exp(x), x, oo) == -oo
assert limit(exp(x)/x, x, oo) == oo
assert limit(1/x - exp(-x), x, oo) == 0
assert limit(x + 1/x, x, oo) == oo
assert limit(x - x**2, x, oo) == -oo
assert limit((1 + x)**(1 + sqrt(2)), x, 0) == 1
assert limit((1 + x)**oo, x, 0) == oo
assert limit((1 + x)**oo, x, 0, dir='-') == 0
assert limit((1 + x + y)**oo, x, 0, dir='-') == (1 + y)**oo
assert limit(y/x/log(x), x, 0) == -oo*sign(y)
assert limit(cos(x + y)/x, x, 0) == sign(cos(y))*oo
limit(Sum(1/x, (x, 1, y)) - log(y), y, oo)
limit(Sum(1/x, (x, 1, y)) - 1/y, y, oo)
assert limit(gamma(1/x + 3), x, oo) == 2
assert limit(nan, x, -oo) == nan
assert limit(O(2)*x, x, nan) == nan
assert limit(sin(O(x)), x, 0) == 0
assert limit(1/(x - 1), x, 1, dir="+") == oo
assert limit(1/(x - 1), x, 1, dir="-") == -oo
assert limit(1/(5 - x)**3, x, 5, dir="+") == -oo
assert limit(1/(5 - x)**3, x, 5, dir="-") == oo
assert limit(1/sin(x), x, pi, dir="+") == -oo
assert limit(1/sin(x), x, pi, dir="-") == oo
assert limit(1/cos(x), x, pi/2, dir="+") == -oo
assert limit(1/cos(x), x, pi/2, dir="-") == oo
assert limit(1/tan(x**3), x, cbrt(2*pi), dir="+") == oo
assert limit(1/tan(x**3), x, cbrt(2*pi), dir="-") == -oo
assert limit(1/cot(x)**3, x, 3*pi/2, dir="+") == -oo
assert limit(1/cot(x)**3, x, 3*pi/2, dir="-") == oo
# approaching 0
# from dir="+"
assert limit(1 + 1/x, x, 0) == oo
# from dir='-'
# Add
assert limit(1 + 1/x, x, 0, dir='-') == -oo
# Pow
assert limit(x**(-2), x, 0, dir='-') == oo
assert limit(x**(-3), x, 0, dir='-') == -oo
assert limit(1/sqrt(x), x, 0, dir='-') == (-oo)*I
assert limit(x**2, x, 0, dir='-') == 0
assert limit(sqrt(x), x, 0, dir='-') == 0
assert limit(x**-pi, x, 0, dir='-') == oo*sign((-1)**(-pi))
assert limit((1 + cos(x))**oo, x, 0) == oo
assert limit(x**2, x, 0, dir='real') == 0
assert limit(exp(x), x, 0, dir='real') == 1
pytest.raises(PoleError, lambda: limit(1/x, x, 0, dir='real'))
def test_floor_requires_robust_assumptions():
assert limit(floor(sin(x)), x, 0, "+") == 0
assert limit(floor(sin(x)), x, 0, "-") == -1
assert limit(floor(cos(x)), x, 0, "+") == 0
assert limit(floor(cos(x)), x, 0, "-") == 0
assert limit(floor(5 + sin(x)), x, 0, "+") == 5
assert limit(floor(5 + sin(x)), x, 0, "-") == 4
assert limit(floor(5 + cos(x)), x, 0, "+") == 5
assert limit(floor(5 + cos(x)), x, 0, "-") == 5
def test_diofantissue_74():
assert gruntz(sign(log(1 + 1/x)), x) == +1
assert gruntz(sign(log(1 - 1/x)), x) == -1
assert gruntz(sign(sin(+1/x)), x) == +1
assert gruntz(sign(sin(-1/x)), x) == -1
assert gruntz(sign(tan(+1/x)), x) == +1
assert gruntz(sign(tan(-1/x)), x) == -1
assert gruntz(sign(cos(pi/2 + 1/x)), x) == -1
assert gruntz(sign(cos(pi/2 - 1/x)), x) == +1
def test_ceiling():
assert ceiling(x).series(x) == 1
assert ceiling(-x).series(x) == 0
assert ceiling(sin(x)).series(x) == 1
assert ceiling(sin(-x)).series(x) == 0
assert ceiling(1 - cos(x)).series(x) == 1
assert ceiling(1 - cos(-x)).series(x) == 1
assert ceiling(x).series(x, 2) == 3
assert ceiling(-x).series(x, 2) == -2
def test_deltaintegrate():
assert deltaintegrate(x, x) is None
assert deltaintegrate(x + DiracDelta(x), x) is None
assert deltaintegrate(DiracDelta(x, 0), x) == Heaviside(x)
for n in range(10):
assert deltaintegrate(DiracDelta(x, n + 1), x) == DiracDelta(x, n)
assert deltaintegrate(DiracDelta(x), x) == Heaviside(x)
assert deltaintegrate(DiracDelta(-x), x) == Heaviside(x)
assert deltaintegrate(DiracDelta(x - y), x) == Heaviside(x - y)
assert deltaintegrate(DiracDelta(y - x), x) == Heaviside(x - y)
assert deltaintegrate(x*DiracDelta(x), x) == 0
assert deltaintegrate((x - y)*DiracDelta(x - y), x) == 0
assert deltaintegrate(DiracDelta(x)**2, x) == DiracDelta(0)*Heaviside(x)
assert deltaintegrate(y*DiracDelta(x)**2, x) == \
y*DiracDelta(0)*Heaviside(x)
assert deltaintegrate(DiracDelta(x, 1)**2, x) is None
assert deltaintegrate(y*DiracDelta(x, 1)**2, x) is None
assert deltaintegrate(DiracDelta(x) * f(x), x) == f(0) * Heaviside(x)
assert deltaintegrate(DiracDelta(-x) * f(x), x) == f(0) * Heaviside(x)
assert deltaintegrate(DiracDelta(x - 1) * f(x), x) == f(1) * Heaviside(x - 1)
assert deltaintegrate(DiracDelta(1 - x) * f(x), x) == f(1) * Heaviside(x - 1)
assert deltaintegrate(DiracDelta(x**2 + x - 2), x) == \
Heaviside(x - 1)/3 + Heaviside(x + 2)/3
p = cos(x)*(DiracDelta(x) + DiracDelta(x**2 - 1))*sin(x)*(x - pi)
assert deltaintegrate(p, x) - (-pi*(cos(1)*Heaviside(-1 + x)*sin(1)/2 -
cos(1)*Heaviside(1 + x)*sin(1)/2) +
cos(1)*Heaviside(1 + x)*sin(1)/2 +
cos(1)*Heaviside(-1 + x)*sin(1)/2) == 0
p = x_2*DiracDelta(x - x_2)*DiracDelta(x_2 - x_1)
assert deltaintegrate(p, x_2) == x*DiracDelta(x - x_1)*Heaviside(x_2 - x)
p = x*y**2*z*DiracDelta(y - x)*DiracDelta(y - z)*DiracDelta(x - z)
assert deltaintegrate(p, y) == x**3*z*DiracDelta(x - z)**2*Heaviside(y - x)
assert deltaintegrate((x + 1)*DiracDelta(2*x), x) == Rational(1, 2) * Heaviside(x)
assert deltaintegrate((x + 1)*DiracDelta(2*x/3 + Rational(4, 9)), x) == \
Rational(1, 2) * Heaviside(x + Rational(2, 3))
a, b, c = symbols('a b c', commutative=False)
assert deltaintegrate(DiracDelta(x - y)*f(x - b)*f(x - a), x) == \
f(y - b)*f(y - a)*Heaviside(x - y)
p = f(x - a)*DiracDelta(x - y)*f(x - c)*f(x - b)
assert deltaintegrate(p, x) == f(y - a)*f(y - c)*f(y - b)*Heaviside(x - y)
p = DiracDelta(x - z)*f(x - b)*f(x - a)*DiracDelta(x - y)
assert deltaintegrate(p, x) == DiracDelta(y - z)*f(y - b)*f(y - a) * \
Heaviside(x - y)
# for test coverage
assert deltaintegrate(DiracDelta(exp(x) - 1), x) is None
assert deltaintegrate((x - 1)*DiracDelta(exp(x) - 1), x) is None
def test_functions_subs():
f, g = symbols('f g', cls=Function)
l = Lambda((x, y), sin(x) + y)
assert (g(y, x) + cos(x)).subs({g: l}) == sin(y) + x + cos(x)
assert (f(x)**2).subs({f: sin}) == sin(x)**2
assert (f(x, y)).subs({f: log}) == log(x, y)
assert (f(x, y)).subs({f: sin}) == f(x, y)
assert (sin(x) + atan2(x, y)).subs({atan2: f, sin: g}) == \
f(x, y) + g(x)
assert (g(f(x + y, x))).subs({f: l, g: Lambda(x, exp(x))}) == exp(x + sin(x + y))
def test_sympyissue_8694():
theta1, theta2, rho = symbols("theta1, theta2, rho")
S1, C1 = sin(theta1), cos(theta1)
X1 = Wild("X1", exclude=[rho, theta1, theta2])
Y1 = Wild("Y1", exclude=[rho, theta1, theta2])
Z1 = Wild("Z1", exclude=[rho, theta1, theta2])
eq = -Y + (-X + Z)*cos(theta1) + (X + Y)*sin(theta1)
assert eq.match(X1*C1 + Y1*S1 + Z1) == {X1: Z - X, Y1: X + Y, Z1: -Y}
eq = -Y + Z*cos(theta1) + (X + Y)*sin(theta1)
assert eq.match(X1*C1 + Y1*S1 + Z1) == {X1: Z, Y1: X + Y, Z1: -Y}
def test_sech():
k = Symbol('k', integer=True)
n = Symbol('n', positive=True)
assert sech(nan) == nan
assert sech(zoo) == nan
assert sech(oo) == 0
assert sech(-oo) == 0
assert sech(0) == 1
assert sech(-1) == sech(1)
assert sech(-x) == sech(x)
assert sech(pi*I) == sec(pi)
assert sech(-pi*I) == sec(pi)
assert sech(-2**1024 * E) == sech(2**1024 * E)
assert sech(pi*I/2) == zoo
assert sech(-pi*I/2) == zoo
assert sech((-3*10**73 + 1)*pi*I/2) == zoo
assert sech((7*10**103 + 1)*pi*I/2) == zoo
assert sech(pi*I) == -1
assert sech(-pi*I) == -1
assert sech(5*pi*I) == -1
assert sech(8*pi*I) == 1
assert sech(pi*I/3) == 2
assert sech(-2*pi*I/3) == -2
assert sech(pi*I/4) == sqrt(2)
assert sech(-pi*I/4) == sqrt(2)
assert sech(5*pi*I/4) == -sqrt(2)
assert sech(-5*pi*I/4) == -sqrt(2)
assert sech(pi*I/6) == 2/sqrt(3)
assert sech(-pi*I/6) == 2/sqrt(3)
assert sech(7*pi*I/6) == -2/sqrt(3)
assert sech(-5*pi*I/6) == -2/sqrt(3)
assert sech(pi*I/105) == 1/cos(pi/105)
assert sech(-pi*I/105) == 1/cos(pi/105)
assert sech(x*I) == 1/cos(x)
assert sech(k*pi*I) == 1/cos(k*pi)
assert sech(17*k*pi*I) == 1/cos(17*k*pi)
assert sech(n).is_extended_real is True
assert csch(n).is_finite is None
pytest.raises(ArgumentIndexError, lambda: sech(x).fdiff(2))
def test_interface():
p, q = map(Wild, 'pq')
assert (x + 1).match(p + 1) == {p: x}
assert (x*3).match(p*3) == {p: x}
assert (x**3).match(p**3) == {p: x}
assert (x*cos(y)).match(p*cos(q)) == {p: x, q: y}
assert (x*y).match(p*q) in [{p: x, q: y}, {p: y, q: x}]
assert (x + y).match(p + q) in [{p: x, q: y}, {p: y, q: x}]
assert (x*y + 1).match(p*q) in [{p: 1, q: 1 + x*y}, {p: 1 + x*y, q: 1}]
def test_sympyissue_8368_7173():
LT = laplace_transform
# hyperbolic
assert LT(sinh(x), x, s) == (1/(s**2 - 1), 1, True)
assert LT(cosh(x), x, s) == (s/(s**2 - 1), 1, True)
assert LT(sinh(x + 3), x, s) == (
(s*sinh(3) + cosh(3))/(s**2 - 1), 1, True)
assert LT(sinh(x)*cosh(x), x, s) == (1/(s**2 - 4), 2, Ne(s/2, 1))
# trig (make sure they are not being rewritten in terms of exp)
assert LT(cos(x + 3), x, s) == ((s*cos(3) - sin(3))/(s**2 + 1), 0, True)
def test_chebyshev():
assert chebyshevt(0, x) == 1
assert chebyshevt(1, x) == x
assert chebyshevt(2, x) == 2*x**2 - 1
assert chebyshevt(3, x) == 4*x**3 - 3*x
assert chebyshevt(-2, x) == 2*x**2 - 1
for n in range(1, 4):
for k in range(n):
z = chebyshevt_root(n, k)
assert chebyshevt(n, z) == 0
pytest.raises(ValueError, lambda: chebyshevt_root(n, n))
for n in range(1, 4):
for k in range(n):
z = chebyshevu_root(n, k)
assert chebyshevu(n, z) == 0
pytest.raises(ValueError, lambda: chebyshevu_root(n, n))
n = Symbol("n")
X = chebyshevt(n, x)
assert isinstance(X, chebyshevt)
assert chebyshevt(n, -x) == (-1)**n*chebyshevt(n, x)
assert chebyshevt(-n, x) == chebyshevt(n, x)
assert chebyshevt(n, oo) == oo
assert chebyshevt(n, 0) == cos(pi*n/2)
assert chebyshevt(n, 1) == 1
assert conjugate(chebyshevt(n, x)) == chebyshevt(n, conjugate(x))
assert diff(chebyshevt(n, x), x) == n*chebyshevu(n - 1, x)
pytest.raises(ArgumentIndexError, lambda: chebyshevt(n, x).fdiff(1))
X = chebyshevu(n, x)
assert isinstance(X, chebyshevu)
assert chebyshevu(n, -x) == (-1)**n*chebyshevu(n, x)
assert chebyshevu(-n, x) == -chebyshevu(n - 2, x)
assert chebyshevu(n, oo) == oo
assert chebyshevu(n, 0) == cos(pi*n/2)
assert chebyshevu(n, 1) == n + 1
assert chebyshevu(-1, x) == 0
assert chebyshevu(-2, x) == -1
assert conjugate(chebyshevu(n, x)) == chebyshevu(n, conjugate(x))
assert diff(chebyshevu(n, x), x) == \
(-x*chebyshevu(n, x) + (n + 1)*chebyshevt(n + 1, x))/(x**2 - 1)
pytest.raises(ArgumentIndexError, lambda: chebyshevu(n, x).fdiff(1))
def test_function_comparable():
assert sin(x).is_comparable is False
assert cos(x).is_comparable is False
assert sin(Float('0.1')).is_comparable is True
assert cos(Float('0.1')).is_comparable is True
assert sin(E).is_comparable is True
assert cos(E).is_comparable is True
assert sin(Rational(1, 3)).is_comparable is True
assert cos(Rational(1, 3)).is_comparable is True
def test_complicated_codegen_f95():
name_expr = [
("test1", ((sin(x) + cos(y) + tan(z))**7).expand()),
("test2", cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))),
]
result = codegen(name_expr, "F95", "file", header=False, empty=False)
assert result[0][0] == "file.f90"
expected = (
'REAL*8 function test1(x, y, z)\n'
'implicit none\n'
'REAL*8, intent(in) :: x\n'
'REAL*8, intent(in) :: y\n'
'REAL*8, intent(in) :: z\n'
'test1 = sin(x)**7 + 7*sin(x)**6*cos(y) + 7*sin(x)**6*tan(z) + 21*sin(x) &\n'
' **5*cos(y)**2 + 42*sin(x)**5*cos(y)*tan(z) + 21*sin(x)**5*tan(z) &\n'
' **2 + 35*sin(x)**4*cos(y)**3 + 105*sin(x)**4*cos(y)**2*tan(z) + &\n'
' 105*sin(x)**4*cos(y)*tan(z)**2 + 35*sin(x)**4*tan(z)**3 + 35*sin( &\n'
' x)**3*cos(y)**4 + 140*sin(x)**3*cos(y)**3*tan(z) + 210*sin(x)**3* &\n'
' cos(y)**2*tan(z)**2 + 140*sin(x)**3*cos(y)*tan(z)**3 + 35*sin(x) &\n'
' **3*tan(z)**4 + 21*sin(x)**2*cos(y)**5 + 105*sin(x)**2*cos(y)**4* &\n'
' tan(z) + 210*sin(x)**2*cos(y)**3*tan(z)**2 + 210*sin(x)**2*cos(y) &\n'
' **2*tan(z)**3 + 105*sin(x)**2*cos(y)*tan(z)**4 + 21*sin(x)**2*tan &\n'
' (z)**5 + 7*sin(x)*cos(y)**6 + 42*sin(x)*cos(y)**5*tan(z) + 105* &\n'
' sin(x)*cos(y)**4*tan(z)**2 + 140*sin(x)*cos(y)**3*tan(z)**3 + 105 &\n'
' *sin(x)*cos(y)**2*tan(z)**4 + 42*sin(x)*cos(y)*tan(z)**5 + 7*sin( &\n'
' x)*tan(z)**6 + cos(y)**7 + 7*cos(y)**6*tan(z) + 21*cos(y)**5*tan( &\n'
' z)**2 + 35*cos(y)**4*tan(z)**3 + 35*cos(y)**3*tan(z)**4 + 21*cos( &\n'
' y)**2*tan(z)**5 + 7*cos(y)*tan(z)**6 + tan(z)**7\n'
'end function\n'
'REAL*8 function test2(x, y, z)\n'
'implicit none\n'
'REAL*8, intent(in) :: x\n'
'REAL*8, intent(in) :: y\n'
'REAL*8, intent(in) :: z\n'
'test2 = cos(cos(cos(cos(cos(cos(cos(cos(x + y + z))))))))\n'
'end function\n'
)
assert result[0][1] == expected
assert result[1][0] == "file.h"
expected = (
'interface\n'
'REAL*8 function test1(x, y, z)\n'
'implicit none\n'
'REAL*8, intent(in) :: x\n'
'REAL*8, intent(in) :: y\n'
'REAL*8, intent(in) :: z\n'
'end function\n'
'end interface\n'
'interface\n'
'REAL*8 function test2(x, y, z)\n'
'implicit none\n'
'REAL*8, intent(in) :: x\n'
'REAL*8, intent(in) :: y\n'
'REAL*8, intent(in) :: z\n'
'end function\n'
'end interface\n'
)
assert result[1][1] == expected
def test__eval_product():
# issue sympy/sympy#4809
a = Function('a')
assert product(2*a(i), (i, 1, n)) == 2**n * Product(a(i), (i, 1, n))
# issue sympy/sympy#4810
assert product(2**i, (i, 1, n)) == 2**(n/2 + n**2/2)
assert (product((i - 1)*(i**6 + i - 1), (i, n, m)) ==
rf(n - 1, m - n + 1)*product(i**6 + i - 1, (i, n, m)))
assert (product(log(i)**2*cos(i)**3, (i, n, m)) ==
Product(log(i)**2*cos(i)**3, (i, n, m)))
def test_cos():
e1 = cos(x).series(x)
assert e1 == 1 - x**2 / 2 + x**4 / 24 + O(x**6)
def test_trigsimp_sympyissue_7131():
n = Symbol('n', integer=True, positive=True)
assert trigsimp(2**(n/2)*cos(pi*n/4)/2 + 2**(n - 1)/2) == \
2**(n/2)*cos(pi*n/4)/2 + 2**n/4
def test_sympyissue_4583():
assert cos(1 + x + x**2).series(x, 0, 5) == cos(1) - x*sin(1) + \
x**2*(-sin(1) - cos(1)/2) + x**3*(-cos(1) + sin(1)/6) + \
x**4*(-11*cos(1)/24 + sin(1)/2) + O(x**5)
def test_trigsimp1():
assert trigsimp(1 - sin(x)**2) == cos(x)**2
assert trigsimp(1 - cos(x)**2) == sin(x)**2
assert trigsimp(sin(x)**2 + cos(x)**2) == 1
assert trigsimp(1 + tan(x)**2) == 1 / cos(x)**2
assert trigsimp(1 / cos(x)**2 - 1) == tan(x)**2
assert trigsimp(1 / cos(x)**2 - tan(x)**2) == 1
assert trigsimp(1 + cot(x)**2) == 1 / sin(x)**2
assert trigsimp(1 / sin(x)**2 - 1) == 1 / tan(x)**2
assert trigsimp(1 / sin(x)**2 - cot(x)**2) == 1
assert trigsimp(5 * cos(x)**2 + 5 * sin(x)**2) == 5
assert trigsimp(5 * cos(x / 2)**2 +
2 * sin(x / 2)**2) == 3 * cos(x) / 2 + Rational(7, 2)
assert trigsimp(sin(x) / cos(x)) == tan(x)
assert trigsimp(2 * tan(x) * cos(x)) == 2 * sin(x)
assert trigsimp(cot(x)**3 * sin(x)**3) == cos(x)**3
assert trigsimp(y * tan(x)**2 / sin(x)**2) == y / cos(x)**2
assert trigsimp(cot(x) / cos(x)) == 1 / sin(x)
assert trigsimp(sin(x + y) + sin(x - y)) == 2 * sin(x) * cos(y)
assert trigsimp(sin(x + y) - sin(x - y)) == 2 * sin(y) * cos(x)
assert trigsimp(cos(x + y) + cos(x - y)) == 2 * cos(x) * cos(y)
assert trigsimp(cos(x + y) - cos(x - y)) == -2 * sin(x) * sin(y)
assert trigsimp(tan(x + y) - tan(x)/(1 - tan(x)*tan(y))) == \
sin(y)/(-sin(y)*tan(x) + cos(y)) # -tan(y)/(tan(x)*tan(y) - 1)
assert trigsimp(sinh(x + y) + sinh(x - y)) == 2 * sinh(x) * cosh(y)
assert trigsimp(sinh(x + y) - sinh(x - y)) == 2 * sinh(y) * cosh(x)
assert trigsimp(cosh(x + y) + cosh(x - y)) == 2 * cosh(x) * cosh(y)
assert trigsimp(cosh(x + y) - cosh(x - y)) == 2 * sinh(x) * sinh(y)
assert trigsimp(tanh(x + y) - tanh(x)/(1 + tanh(x)*tanh(y))) == \
sinh(y)/(sinh(y)*tanh(x) + cosh(y))
assert trigsimp(cos(0.12345)**2 + sin(0.12345)**2) == 1
e = 2 * sin(x)**2 + 2 * cos(x)**2
assert trigsimp(log(e)) == log(2)
def test_trigsimp_issues():
# issue sympy/sympy#4625 - factor_terms works, too
assert trigsimp(sin(x)**3 + cos(x)**2 * sin(x)) == sin(x)
# issue sympy/sympy#5948
assert trigsimp(diff(integrate(cos(x)/sin(x)**3, x), x)) == \
cos(x)/sin(x)**3
assert trigsimp(diff(integrate(sin(x)/cos(x)**3, x), x)) == \
sin(x)/cos(x)**3
# check integer exponents
e = sin(x)**y / cos(x)**y
assert trigsimp(e) == e
assert trigsimp(e.subs(y, 2)) == tan(x)**2
assert trigsimp(e.subs(x, 1)) == tan(1)**y
# check for multiple patterns
assert (cos(x)**2/sin(x)**2*cos(y)**2/sin(y)**2).trigsimp() == \
1/tan(x)**2/tan(y)**2
assert trigsimp(cos(x)/sin(x)*cos(x+y)/sin(x+y)) == \
1/(tan(x)*tan(x + y))
eq = cos(2) * (cos(3) + 1)**2 / (cos(3) - 1)**2
assert trigsimp(eq) == eq.factor() # factor makes denom (-1 + cos(3))**2
assert trigsimp(cos(2)*(cos(3) + 1)**2*(cos(3) - 1)**2) == \
cos(2)*sin(3)**4
# issue sympy/sympy#6789; this generates an expression that formerly caused
# trigsimp to hang
assert cot(x).equals(tan(x)) is False
# nan or the unchanged expression is ok, but not sin(1)
z = cos(x)**2 + sin(x)**2 - 1
z1 = tan(x)**2 - 1 / cot(x)**2
n = (1 + z1 / z)
assert trigsimp(sin(n)) != sin(1)
eq = x * (n - 1) - x * n
assert trigsimp(eq) is nan
assert trigsimp(eq, recursive=True) is nan
assert trigsimp(1).is_Integer
assert trigsimp(-sin(x)**4 - 2 * sin(x)**2 * cos(x)**2 - cos(x)**4) == -1
def test_sympyissue_4661():
eq = -4 * sin(x)**4 + 4 * cos(x)**4 - 8 * cos(x)**2
assert trigsimp(eq) == -4
n = sin(x)**6 + 4 * sin(x)**4 * cos(x)**2 + 5 * sin(x)**2 * cos(
x)**4 + 2 * cos(x)**6
d = -sin(x)**2 - 2 * cos(x)**2
assert simplify(n / d) == -1
assert trigsimp(-2 * cos(x)**2 + cos(x)**4 - sin(x)**4) == -1
eq = (-sin(x)**3 / 4) * cos(x) + (cos(x)**3 / 4) * sin(x) - sin(
2 * x) * cos(2 * x) / 8
assert trigsimp(eq) == 0
def test_sympyissue_5948():
assert trigsimp(diff(integrate(cos(x) / sin(x)**7, x),
x)) == cos(x) / sin(x)**7
def test_sin():
assert sin(8 * x).nseries(x, n=4) == 8 * x - 256 * x**3 / 3 + O(x**5)
assert sin(x + y).nseries(x, n=1) == sin(y) + O(x)
assert sin(x + y).nseries(x, n=2) == sin(y) + cos(y) * x + O(x**2)
assert sin(x + y).nseries(x, n=5) == sin(y) + cos(y)*x - sin(y)*x**2/2 - \
cos(y)*x**3/6 + sin(y)*x**4/24 + O(x**5)
def test_sympyissue_3505():
e = sin(x)**(-4) * (sqrt(cos(x)) * sin(x)**2 - cbrt(cos(x)) * sin(x)**2)
assert e.nseries(x, n=8) == -Rational(1, 12) - 7*x**2/288 - \
43*x**4/10368 + O(x**6)
def test_fresnel():
assert expand_func(integrate(sin(pi * x**2 / 2), x)) == fresnels(x)
assert expand_func(integrate(cos(pi * x**2 / 2), x)) == fresnelc(x)
def test_express():
assert express(Vector.zero, N) == Vector.zero
assert express(Integer(0), N) == Integer(0)
assert express(A.i, C) == cos(q3)*C.i + sin(q3)*C.k
assert express(A.j, C) == sin(q2)*sin(q3)*C.i + cos(q2)*C.j - \
sin(q2)*cos(q3)*C.k
assert express(A.k, C) == -sin(q3)*cos(q2)*C.i + sin(q2)*C.j + \
cos(q2)*cos(q3)*C.k
assert express(A.i, N) == cos(q1)*N.i + sin(q1)*N.j
assert express(A.j, N) == -sin(q1)*N.i + cos(q1)*N.j
assert express(A.k, N) == N.k
assert express(A.i, A) == A.i
assert express(A.j, A) == A.j
assert express(A.k, A) == A.k
assert express(A.i, B) == B.i
assert express(A.j, B) == cos(q2)*B.j - sin(q2)*B.k
assert express(A.k, B) == sin(q2)*B.j + cos(q2)*B.k
assert express(A.i, C) == cos(q3)*C.i + sin(q3)*C.k
assert express(A.j, C) == sin(q2)*sin(q3)*C.i + cos(q2)*C.j - \
sin(q2)*cos(q3)*C.k
assert express(A.k, C) == -sin(q3)*cos(q2)*C.i + sin(q2)*C.j + \
cos(q2)*cos(q3)*C.k
# Check to make sure UnitVectors get converted properly
assert express(N.i, N) == N.i
assert express(N.j, N) == N.j
assert express(N.k, N) == N.k
assert express(N.i, A) == (cos(q1)*A.i - sin(q1)*A.j)
assert express(N.j, A) == (sin(q1)*A.i + cos(q1)*A.j)
assert express(N.k, A) == A.k
assert express(N.i, B) == (cos(q1)*B.i - sin(q1)*cos(q2)*B.j +
sin(q1)*sin(q2)*B.k)
assert express(N.j, B) == (sin(q1)*B.i + cos(q1)*cos(q2)*B.j -
sin(q2)*cos(q1)*B.k)
assert express(N.k, B) == (sin(q2)*B.j + cos(q2)*B.k)
assert express(N.i, C) == (
(cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*C.i -
sin(q1)*cos(q2)*C.j +
(sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*C.k)
assert express(N.j, C) == (
(sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*C.i +
cos(q1)*cos(q2)*C.j +
(sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*C.k)
assert express(N.k, C) == (-sin(q3)*cos(q2)*C.i + sin(q2)*C.j +
cos(q2)*cos(q3)*C.k)
assert express(A.i, N) == (cos(q1)*N.i + sin(q1)*N.j)
assert express(A.j, N) == (-sin(q1)*N.i + cos(q1)*N.j)
assert express(A.k, N) == N.k
assert express(A.i, A) == A.i
assert express(A.j, A) == A.j
assert express(A.k, A) == A.k
assert express(A.i, B) == B.i
assert express(A.j, B) == (cos(q2)*B.j - sin(q2)*B.k)
assert express(A.k, B) == (sin(q2)*B.j + cos(q2)*B.k)
assert express(A.i, C) == (cos(q3)*C.i + sin(q3)*C.k)
assert express(A.j, C) == (sin(q2)*sin(q3)*C.i + cos(q2)*C.j -
sin(q2)*cos(q3)*C.k)
assert express(A.k, C) == (-sin(q3)*cos(q2)*C.i + sin(q2)*C.j +
cos(q2)*cos(q3)*C.k)
assert express(B.i, N) == (cos(q1)*N.i + sin(q1)*N.j)
assert express(B.j, N) == (-sin(q1)*cos(q2)*N.i +
cos(q1)*cos(q2)*N.j + sin(q2)*N.k)
assert express(B.k, N) == (sin(q1)*sin(q2)*N.i -
sin(q2)*cos(q1)*N.j + cos(q2)*N.k)
assert express(B.i, A) == A.i
assert express(B.j, A) == (cos(q2)*A.j + sin(q2)*A.k)
assert express(B.k, A) == (-sin(q2)*A.j + cos(q2)*A.k)
assert express(B.i, B) == B.i
assert express(B.j, B) == B.j
assert express(B.k, B) == B.k
assert express(B.i, C) == (cos(q3)*C.i + sin(q3)*C.k)
assert express(B.j, C) == C.j
assert express(B.k, C) == (-sin(q3)*C.i + cos(q3)*C.k)
assert express(C.i, N) == (
(cos(q1)*cos(q3) - sin(q1)*sin(q2)*sin(q3))*N.i +
(sin(q1)*cos(q3) + sin(q2)*sin(q3)*cos(q1))*N.j -
sin(q3)*cos(q2)*N.k)
assert express(C.j, N) == (
-sin(q1)*cos(q2)*N.i + cos(q1)*cos(q2)*N.j + sin(q2)*N.k)
assert express(C.k, N) == (
(sin(q3)*cos(q1) + sin(q1)*sin(q2)*cos(q3))*N.i +
(sin(q1)*sin(q3) - sin(q2)*cos(q1)*cos(q3))*N.j +
cos(q2)*cos(q3)*N.k)
assert express(C.i, A) == (cos(q3)*A.i + sin(q2)*sin(q3)*A.j -
sin(q3)*cos(q2)*A.k)
assert express(C.j, A) == (cos(q2)*A.j + sin(q2)*A.k)
assert express(C.k, A) == (sin(q3)*A.i - sin(q2)*cos(q3)*A.j +
cos(q2)*cos(q3)*A.k)
assert express(C.i, B) == (cos(q3)*B.i - sin(q3)*B.k)
assert express(C.j, B) == B.j
assert express(C.k, B) == (sin(q3)*B.i + cos(q3)*B.k)
assert express(C.i, C) == C.i
assert express(C.j, C) == C.j
assert express(C.k, C) == C.k == (C.k)
# Check to make sure Vectors get converted back to UnitVectors
assert N.i == express((cos(q1)*A.i - sin(q1)*A.j), N).simplify()
assert N.j == express((sin(q1)*A.i + cos(q1)*A.j), N).simplify()
assert N.i == express((cos(q1)*B.i - sin(q1)*cos(q2)*B.j +
sin(q1)*sin(q2)*B.k), N).simplify()
assert N.j == express((sin(q1)*B.i + cos(q1)*cos(q2)*B.j -
sin(q2)*cos(q1)*B.k), N).simplify()
assert N.k == express((sin(q2)*B.j + cos(q2)*B.k), N).simplify()
assert A.i == express((cos(q1)*N.i + sin(q1)*N.j), A).simplify()
assert A.j == express((-sin(q1)*N.i + cos(q1)*N.j), A).simplify()
assert A.j == express((cos(q2)*B.j - sin(q2)*B.k), A).simplify()
assert A.k == express((sin(q2)*B.j + cos(q2)*B.k), A).simplify()
assert A.i == express((cos(q3)*C.i + sin(q3)*C.k), A).simplify()
assert A.j == express((sin(q2)*sin(q3)*C.i + cos(q2)*C.j -
sin(q2)*cos(q3)*C.k), A).simplify()
assert A.k == express((-sin(q3)*cos(q2)*C.i + sin(q2)*C.j +
cos(q2)*cos(q3)*C.k), A).simplify()
assert B.i == express((cos(q1)*N.i + sin(q1)*N.j), B).simplify()
assert B.j == express((-sin(q1)*cos(q2)*N.i +
cos(q1)*cos(q2)*N.j + sin(q2)*N.k), B).simplify()
assert B.k == express((sin(q1)*sin(q2)*N.i -
sin(q2)*cos(q1)*N.j + cos(q2)*N.k), B).simplify()
assert B.j == express((cos(q2)*A.j + sin(q2)*A.k), B).simplify()
assert B.k == express((-sin(q2)*A.j + cos(q2)*A.k), B).simplify()
assert B.i == express((cos(q3)*C.i + sin(q3)*C.k), B).simplify()
assert B.k == express((-sin(q3)*C.i + cos(q3)*C.k), B).simplify()
assert C.i == express((cos(q3)*A.i + sin(q2)*sin(q3)*A.j -
sin(q3)*cos(q2)*A.k), C).simplify()
assert C.j == express((cos(q2)*A.j + sin(q2)*A.k), C).simplify()
assert C.k == express((sin(q3)*A.i - sin(q2)*cos(q3)*A.j +
cos(q2)*cos(q3)*A.k), C).simplify()
assert C.i == express((cos(q3)*B.i - sin(q3)*B.k), C).simplify()
assert C.k == express((sin(q3)*B.i + cos(q3)*B.k), C).simplify()
def test_linear_subs():
assert integrate(sin(x - 1), x, meijerg=True) == -cos(1 - x)
assert integrate(besselj(1, x - 1), x, meijerg=True) == -besselj(0, 1 - x)
def test_del_operator():
# Tests for curl
assert (delop
^ Vector.zero == (Derivative(0, C.y) - Derivative(0, C.z)) * C.i +
(-Derivative(0, C.x) + Derivative(0, C.z)) * C.j +
(Derivative(0, C.x) - Derivative(0, C.y)) * C.k)
assert ((delop ^ Vector.zero).doit() == Vector.zero == curl(
Vector.zero, C))
assert delop.cross(Vector.zero) == delop ^ Vector.zero
assert (delop ^ i).doit() == Vector.zero
assert delop.cross(2 * y**2 * j, doit=True) == Vector.zero
assert delop.cross(2 * y**2 * j) == delop ^ 2 * y**2 * j
v = x * y * z * (i + j + k)
assert ((delop ^ v).doit() == (-x * y + x * z) * i + (x * y - y * z) * j +
(-x * z + y * z) * k == curl(v, C))
assert delop ^ v == delop.cross(v)
assert (delop.cross(
2 * x**2 *
j) == (Derivative(0, C.y) - Derivative(2 * C.x**2, C.z)) * C.i +
(-Derivative(0, C.x) + Derivative(0, C.z)) * C.j +
(-Derivative(0, C.y) + Derivative(2 * C.x**2, C.x)) * C.k)
assert (delop.cross(2 * x**2 * j, doit=True) == 4 * x * k == curl(
2 * x**2 * j, C))
# Tests for divergence
assert delop & Vector.zero == Integer(0) == divergence(Vector.zero, C)
assert (delop & Vector.zero).doit() == Integer(0)
assert delop.dot(Vector.zero) == delop & Vector.zero
assert (delop & i).doit() == Integer(0)
assert (delop & x**2 * i).doit() == 2 * x == divergence(x**2 * i, C)
assert (delop.dot(v, doit=True) == x * y + y * z + z * x == divergence(
v, C))
assert delop & v == delop.dot(v)
assert delop.dot(1/(x*y*z) * (i + j + k), doit=True) == \
- 1 / (x*y*z**2) - 1 / (x*y**2*z) - 1 / (x**2*y*z)
v = x * i + y * j + z * k
assert (delop & v == Derivative(C.x, C.x) + Derivative(C.y, C.y) +
Derivative(C.z, C.z))
assert delop.dot(v, doit=True) == 3 == divergence(v, C)
assert delop & v == delop.dot(v)
assert simplify((delop & v).doit()) == 3
# Tests for gradient
assert (delop.gradient(0, doit=True) == Vector.zero == gradient(0, C))
assert delop.gradient(0) == delop(0)
assert (delop(Integer(0))).doit() == Vector.zero
assert (delop(x) == (Derivative(C.x, C.x)) * C.i +
(Derivative(C.x, C.y)) * C.j + (Derivative(C.x, C.z)) * C.k)
assert (delop(x)).doit() == i == gradient(x, C)
assert (delop(x * y * z) == (Derivative(C.x * C.y * C.z, C.x)) * C.i +
(Derivative(C.x * C.y * C.z, C.y)) * C.j +
(Derivative(C.x * C.y * C.z, C.z)) * C.k)
assert (delop.gradient(x * y * z, doit=True) ==
y * z * i + z * x * j + x * y * k == gradient(x * y * z, C))
assert delop(x * y * z) == delop.gradient(x * y * z)
assert (delop(2 * x**2)).doit() == 4 * x * i
assert ((delop(a * sin(y) / x)).doit() == -a * sin(y) / x**2 * i +
a * cos(y) / x * j)
# Tests for directional derivative
assert (Vector.zero & delop)(a) == Integer(0)
assert ((Vector.zero & delop)(a)).doit() == Integer(0)
assert ((v & delop)(Vector.zero)).doit() == Vector.zero
assert ((v & delop)(Integer(0))).doit() == Integer(0)
assert ((i & delop)(x)).doit() == 1
assert ((j & delop)(y)).doit() == 1
assert ((k & delop)(z)).doit() == 1
assert ((i & delop)(x * y * z)).doit() == y * z
assert ((v & delop)(x)).doit() == x
assert ((v & delop)(x * y * z)).doit() == 3 * x * y * z
assert (v & delop)(x + y + z) == C.x + C.y + C.z
assert ((v & delop)(x + y + z)).doit() == x + y + z
assert ((v & delop)(v)).doit() == v
assert ((i & delop)(v)).doit() == i
assert ((j & delop)(v)).doit() == j
assert ((k & delop)(v)).doit() == k
assert ((v & delop)(Vector.zero)).doit() == Vector.zero
def test_euler_pendulum():
x = Function('x')
t = Symbol('t')
L = D(x(t), t)**2 / 2 + cos(x(t))
assert euler(L, x(t), t) == [Eq(-sin(x(t)) - D(x(t), t, t))]
def test_sympyissue_5236():
assert (cos(1 + I)**3).as_real_imag() == (
-3 * sin(1)**2 * sinh(1)**2 * cos(1) * cosh(1) +
cos(1)**3 * cosh(1)**3,
-3 * cos(1)**2 * cosh(1)**2 * sin(1) * sinh(1) +
sin(1)**3 * sinh(1)**3)
def test_sympyissue_3503():
e = sin(2 + x) / (2 + x)
assert e.nseries(
x, n=2) == sin(2) / 2 + x * (-sin(2) / 4 + cos(2) / 2) + O(x**2)
def test_evalc():
x = Symbol('x', extended_real=True)
y = Symbol('y', extended_real=True)
assert ((x + I * y)**2).expand(complex=True) == x**2 + 2 * I * x * y - y**2
assert expand_complex(z**(2 * I)) == (re(
(re(z) + I * im(z))**(2 * I)) + I * im((re(z) + I * im(z))**(2 * I)))
assert expand_complex(z**(2 * I),
deep=False) == I * im(z**(2 * I)) + re(z**(2 * I))
assert exp(I * x) != cos(x) + I * sin(x)
assert exp(I * x).expand(complex=True) == cos(x) + I * sin(x)
assert exp(I * x +
y).expand(complex=True) == exp(y) * cos(x) + I * sin(x) * exp(y)
assert sin(I * x).expand(complex=True) == I * sinh(x)
assert sin(x + I*y).expand(complex=True) == sin(x)*cosh(y) + \
I * sinh(y) * cos(x)
assert cos(I * x).expand(complex=True) == cosh(x)
assert cos(x + I*y).expand(complex=True) == cos(x)*cosh(y) - \
I * sinh(y) * sin(x)
assert tan(I * x).expand(complex=True) == tanh(x) * I
assert tan(x + I * y).expand(
complex=True) == (sin(2 * x) / (cos(2 * x) + cosh(2 * y)) +
I * sinh(2 * y) / (cos(2 * x) + cosh(2 * y)))
assert sinh(I * x).expand(complex=True) == I * sin(x)
assert sinh(x + I*y).expand(complex=True) == sinh(x)*cos(y) + \
I * sin(y) * cosh(x)
assert cosh(I * x).expand(complex=True) == cos(x)
assert cosh(x + I*y).expand(complex=True) == cosh(x)*cos(y) + \
I * sin(y) * sinh(x)
assert tanh(I * x).expand(complex=True) == tan(x) * I
assert tanh(x + I * y).expand(
complex=True) == ((sinh(x) * cosh(x) + I * cos(y) * sin(y)) /
(sinh(x)**2 + cos(y)**2)).expand()
def test_sympyissue_3507():
e = x**(-4) * (x**2 - x**2 * sqrt(cos(x)))
assert e.nseries(x, n=7) == \
Rational(1, 4) + x**2/96 + 19*x**4/5760 + O(x**6)
def test_sympyissue_4494():
eq = sin(a)**2 * sin(b)**2 + cos(a)**2 * cos(b)**2 * tan(a)**2 + cos(a)**2
assert trigsimp(eq) == 1
def test_sympyissue_3639():
assert sin(cos(x)).nseries(x, n=5) == \
sin(1) - x**2*cos(1)/2 + x**4*(-sin(1)/8 + cos(1)/24) + O(x**5)
def test_sympyissue_4775():
assert trigsimp(sin(x) * cos(y) + cos(x) * sin(y)) == sin(x + y)
assert trigsimp(sin(x) * cos(y) + cos(x) * sin(y) + 3) == sin(x + y) + 3
def test_sympyissue_4115():
assert (sin(x) / (1 - cos(x))).nseries(x, n=4) == 2 / x + O(x)
assert (sin(x)**2 / (1 - cos(x))).nseries(x, n=2) == 2 + O(x**2)
def test_sympyissue_3210():
eqs = (sin(2) * cos(3) + sin(3) * cos(2), -sin(2) * sin(3) +
cos(2) * cos(3), sin(2) * cos(3) - sin(3) * cos(2),
sin(2) * sin(3) + cos(2) * cos(3), sin(2) * sin(3) +
cos(2) * cos(3) + cos(2), sinh(2) * cosh(3) + sinh(3) * cosh(2),
sinh(2) * sinh(3) + cosh(2) * cosh(3))
assert [trigsimp(e) for e in eqs] == [
sin(5),
cos(5), -sin(1),
cos(1),
cos(1) + cos(2),
sinh(5),
cosh(5)
]
def test_fresnel():
assert fresnels(0) == 0
assert fresnels(+oo) == Rational(+1, 2)
assert fresnels(-oo) == Rational(-1, 2)
assert fresnels(z) == fresnels(z)
assert fresnels(-z) == -fresnels(z)
assert fresnels(I * z) == -I * fresnels(z)
assert fresnels(-I * z) == I * fresnels(z)
assert conjugate(fresnels(z)) == fresnels(conjugate(z))
assert fresnels(z).diff(z) == sin(pi * z**2 / 2)
assert fresnels(z).rewrite(erf) == (1 + I) / 4 * (erf(
(1 + I) / 2 * sqrt(pi) * z) - I * erf((1 - I) / 2 * sqrt(pi) * z))
assert fresnels(z).rewrite(hyper) == \
pi*z**3/6 * hyper([Rational(3, 4)], [Rational(3, 2), Rational(7, 4)], -pi**2*z**4/16)
assert fresnels(z).series(z, n=15) == \
pi*z**3/6 - pi**3*z**7/336 + pi**5*z**11/42240 + O(z**15)
assert fresnels(y / z).limit(z, 0) == fresnels(oo * sign(y))
assert fresnels(x).taylor_term(-1, z) == 0
assert fresnels(x).taylor_term(1, z,
*(pi * z**3 / 6, )) == -pi**3 * z**7 / 336
assert fresnels(x).taylor_term(1, z) == -pi**3 * z**7 / 336
assert fresnels(w).is_extended_real is True
assert fresnels(z).is_extended_real is None
assert fresnels(z).as_real_imag() == \
((fresnels(re(z) - I*re(z)*Abs(im(z))/Abs(re(z)))/2 +
fresnels(re(z) + I*re(z)*Abs(im(z))/Abs(re(z)))/2,
I*(fresnels(re(z) - I*re(z)*Abs(im(z))/Abs(re(z))) -
fresnels(re(z) + I*re(z)*Abs(im(z))/Abs(re(z)))) *
re(z)*Abs(im(z))/(2*im(z)*Abs(re(z)))))
assert fresnels(z).as_real_imag(deep=False) == fresnels(z).as_real_imag()
assert fresnels(w).as_real_imag() == (fresnels(w), 0)
assert fresnels(w).as_real_imag(deep=False) == fresnels(w).as_real_imag()
assert (fresnels(I, evaluate=False).as_real_imag() == (
0, -erf(sqrt(pi) / 2 + I * sqrt(pi) / 2) / 4 + I *
(-erf(sqrt(pi) / 2 + I * sqrt(pi) / 2) +
erf(sqrt(pi) / 2 - I * sqrt(pi) / 2)) / 4 -
erf(sqrt(pi) / 2 - I * sqrt(pi) / 2) / 4))
assert fresnels(2 + 3 * I).as_real_imag() == (
fresnels(2 + 3 * I) / 2 + fresnels(2 - 3 * I) / 2,
I * (fresnels(2 - 3 * I) - fresnels(2 + 3 * I)) / 2)
assert expand_func(integrate(fresnels(z), z)) == \
z*fresnels(z) + cos(pi*z**2/2)/pi
assert fresnels(z).rewrite(meijerg) == sqrt(2)*pi*z**Rational(9, 4) * \
meijerg(((), (1,)), ((Rational(3, 4),),
(Rational(1, 4), 0)), -pi**2*z**4/16)/(2*(-z)**Rational(3, 4)*(z**2)**Rational(3, 4))
assert fresnelc(0) == 0
assert fresnelc(+oo) == Rational(+1, 2)
assert fresnelc(-oo) == Rational(-1, 2)
assert fresnelc(z) == fresnelc(z)
assert fresnelc(-z) == -fresnelc(z)
assert fresnelc(I * z) == I * fresnelc(z)
assert fresnelc(-I * z) == -I * fresnelc(z)
assert conjugate(fresnelc(z)) == fresnelc(conjugate(z))
assert fresnelc(z).diff(z) == cos(pi * z**2 / 2)
pytest.raises(ArgumentIndexError, lambda: fresnels(z).fdiff(2))
pytest.raises(ArgumentIndexError, lambda: fresnelc(z).fdiff(2))
assert fresnelc(z).rewrite(erf) == (1 - I) / 4 * (erf(
(1 + I) / 2 * sqrt(pi) * z) + I * erf((1 - I) / 2 * sqrt(pi) * z))
assert fresnelc(z).rewrite(hyper) == \
z * hyper([Rational(1, 4)], [Rational(1, 2), Rational(5, 4)], -pi**2*z**4/16)
assert fresnelc(x).taylor_term(-1, z) == 0
assert fresnelc(x).taylor_term(1, z, *(z, )) == -pi**2 * z**5 / 40
assert fresnelc(x).taylor_term(1, z) == -pi**2 * z**5 / 40
assert fresnelc(z).series(z, n=15) == \
z - pi**2*z**5/40 + pi**4*z**9/3456 - pi**6*z**13/599040 + O(z**15)
assert fresnelc(y / z).limit(z, 0) == fresnelc(oo * sign(y))
# issue sympy/sympy#6510
assert fresnels(z).series(z, oo) == \
(-1/(pi**2*z**3) + O(z**(-6), (z, oo)))*sin(pi*z**2/2) + \
(3/(pi**3*z**5) - 1/(pi*z) + O(z**(-6), (z, oo)))*cos(pi*z**2/2) + Rational(1, 2)
assert fresnelc(z).series(z, oo) == \
(-1/(pi**2*z**3) + O(z**(-6), (z, oo)))*cos(pi*z**2/2) + \
(-3/(pi**3*z**5) + 1/(pi*z) + O(z**(-6), (z, oo)))*sin(pi*z**2/2) + Rational(1, 2)
assert fresnels(1/z).series(z) == \
(-z**3/pi**2 + O(z**6))*sin(pi/(2*z**2)) + (-z/pi + 3*z**5/pi**3 +
O(z**6))*cos(pi/(2*z**2)) + Rational(1, 2)
assert fresnelc(1/z).series(z) == \
(-z**3/pi**2 + O(z**6))*cos(pi/(2*z**2)) + (z/pi - 3*z**5/pi**3 +
O(z**6))*sin(pi/(2*z**2)) + Rational(1, 2)
assert fresnelc(w).is_extended_real is True
assert fresnelc(z).as_real_imag() == \
((fresnelc(re(z) - I*re(z)*Abs(im(z))/Abs(re(z)))/2 +
fresnelc(re(z) + I*re(z)*Abs(im(z))/Abs(re(z)))/2,
I*(fresnelc(re(z) - I*re(z)*Abs(im(z))/Abs(re(z))) -
fresnelc(re(z) + I*re(z)*Abs(im(z))/Abs(re(z)))) *
re(z)*Abs(im(z))/(2*im(z)*Abs(re(z)))))
assert fresnelc(2 + 3 * I).as_real_imag() == (
fresnelc(2 - 3 * I) / 2 + fresnelc(2 + 3 * I) / 2,
I * (fresnelc(2 - 3 * I) - fresnelc(2 + 3 * I)) / 2)
assert expand_func(integrate(fresnelc(z), z)) == \
z*fresnelc(z) - sin(pi*z**2/2)/pi
assert fresnelc(z).rewrite(meijerg) == sqrt(2)*pi*z**Rational(3, 4) * \
meijerg(((), (1,)), ((Rational(1, 4),),
(Rational(3, 4), 0)), -pi**2*z**4/16)/(2*root(-z, 4)*root(z**2, 4))
verify_numerically(re(fresnels(z)), fresnels(z).as_real_imag()[0], z)
verify_numerically(im(fresnels(z)), fresnels(z).as_real_imag()[1], z)
verify_numerically(fresnels(z), fresnels(z).rewrite(hyper), z)
verify_numerically(fresnels(z), fresnels(z).rewrite(meijerg), z)
verify_numerically(re(fresnelc(z)), fresnelc(z).as_real_imag()[0], z)
verify_numerically(im(fresnelc(z)), fresnelc(z).as_real_imag()[1], z)
verify_numerically(fresnelc(z), fresnelc(z).rewrite(hyper), z)
verify_numerically(fresnelc(z), fresnelc(z).rewrite(meijerg), z)
def test_trigsimp_sympyissue_5614():
assert trigsimp(x * cos(x) * tan(x)) == x * sin(x)
assert trigsimp(-sin(x) + cos(x) * tan(x)) == 0
def fdiff(self, argindex=1):
return cos(self.args[0])
def test_trigsimp_noncommutative():
A, B = symbols('A,B', commutative=False)
assert trigsimp(A - A * sin(x)**2) == A * cos(x)**2
assert trigsimp(A - A * cos(x)**2) == A * sin(x)**2
assert trigsimp(A * sin(x)**2 + A * cos(x)**2) == A
assert trigsimp(A + A * tan(x)**2) == A / cos(x)**2
assert trigsimp(A / cos(x)**2 - A) == A * tan(x)**2
assert trigsimp(A / cos(x)**2 - A * tan(x)**2) == A
assert trigsimp(A + A * cot(x)**2) == A / sin(x)**2
assert trigsimp(A / sin(x)**2 - A) == A / tan(x)**2
assert trigsimp(A / sin(x)**2 - A * cot(x)**2) == A
assert trigsimp(y * A * cos(x)**2 + y * A * sin(x)**2) == y * A
assert trigsimp(A * sin(x) / cos(x)) == A * tan(x)
assert trigsimp(A * tan(x) * cos(x)) == A * sin(x)
assert trigsimp(A * cot(x)**3 * sin(x)**3) == A * cos(x)**3
assert trigsimp(y * A * tan(x)**2 / sin(x)**2) == y * A / cos(x)**2
assert trigsimp(A * cot(x) / cos(x)) == A / sin(x)
assert trigsimp(A * sin(x + y) + A * sin(x - y)) == 2 * A * sin(x) * cos(y)
assert trigsimp(A * sin(x + y) - A * sin(x - y)) == 2 * A * sin(y) * cos(x)
assert trigsimp(A * cos(x + y) + A * cos(x - y)) == 2 * A * cos(x) * cos(y)
assert trigsimp(A * cos(x + y) -
A * cos(x - y)) == -2 * A * sin(x) * sin(y)
assert trigsimp(A * sinh(x + y) +
A * sinh(x - y)) == 2 * A * sinh(x) * cosh(y)
assert trigsimp(A * sinh(x + y) -
A * sinh(x - y)) == 2 * A * sinh(y) * cosh(x)
assert trigsimp(A * cosh(x + y) +
A * cosh(x - y)) == 2 * A * cosh(x) * cosh(y)
assert trigsimp(A * cosh(x + y) -
A * cosh(x - y)) == 2 * A * sinh(x) * sinh(y)
assert trigsimp(A * cos(0.12345)**2 + A * sin(0.12345)**2) == 1.0 * A
def test_roots0():
assert roots(1, x) == {}
assert roots(x, x) == {0: 1}
assert roots(x**9, x) == {0: 9}
assert roots(((x - 2) * (x + 3) * (x - 4)).expand(), x) == {
-3: 1,
2: 1,
4: 1
}
assert roots(x**2 - 2 * x + 1, x, auto=False) == {1: 2}
assert roots(2 * x + 1, x) == {Rational(-1, 2): 1}
assert roots((2 * x + 1)**2, x) == {Rational(-1, 2): 2}
assert roots((2 * x + 1)**5, x) == {Rational(-1, 2): 5}
assert roots((2 * x + 1)**10, x) == {Rational(-1, 2): 10}
assert roots(x**4 - 1, x) == {I: 1, 1: 1, -1: 1, -I: 1}
assert roots((x**4 - 1)**2, x) == {I: 2, 1: 2, -1: 2, -I: 2}
assert roots(((2 * x - 3)**2).expand(), x) == {+Rational(3, 2): 2}
assert roots(((2 * x + 3)**2).expand(), x) == {-Rational(3, 2): 2}
assert roots(((2 * x - 3)**3).expand(), x) == {+Rational(3, 2): 3}
assert roots(((2 * x + 3)**3).expand(), x) == {-Rational(3, 2): 3}
assert roots(((2 * x - 3)**5).expand(), x) == {+Rational(3, 2): 5}
assert roots(((2 * x + 3)**5).expand(), x) == {-Rational(3, 2): 5}
assert roots(((a * x - b)**5).expand(), x) == {+b / a: 5}
assert roots(((a * x + b)**5).expand(), x) == {-b / a: 5}
assert roots(x**2 + (-a - 1) * x + a, x) == {a: 1, 1: 1}
assert roots(x**4 - 2 * x**2 + 1, x) == {1: 2, -1: 2}
assert roots(x**6 - 4*x**4 + 4*x**3 - x**2, x) == \
{1: 2, -1 - sqrt(2): 1, 0: 2, -1 + sqrt(2): 1}
assert roots(x**8 - 1, x) == {
sqrt(2) / 2 + I * sqrt(2) / 2: 1,
sqrt(2) / 2 - I * sqrt(2) / 2: 1,
-sqrt(2) / 2 + I * sqrt(2) / 2: 1,
-sqrt(2) / 2 - I * sqrt(2) / 2: 1,
1: 1,
-1: 1,
I: 1,
-I: 1
}
f = -2016*x**2 - 5616*x**3 - 2056*x**4 + 3324*x**5 + 2176*x**6 - \
224*x**7 - 384*x**8 - 64*x**9
assert roots(f) == {
0: 2,
-2: 2,
2: 1,
-Rational(7, 2): 1,
-Rational(3, 2): 1,
-Rational(1, 2): 1,
Rational(3, 2): 1
}
assert roots((a + b + c) * x - (a + b + c + d), x) == {
(a + b + c + d) / (a + b + c): 1
}
assert roots(x**3 + x**2 - x + 1, x, cubics=False) == {}
assert roots(((x - 2) * (x + 3) * (x - 4)).expand(), x, cubics=False) == {
-3: 1,
2: 1,
4: 1
}
assert roots(((x - 2)*(x + 3)*(x - 4)*(x - 5)).expand(), x, cubics=False) == \
{-3: 1, 2: 1, 4: 1, 5: 1}
assert roots(x**3 + 2 * x**2 + 4 * x + 8, x) == {
-2: 1,
-2 * I: 1,
2 * I: 1
}
assert roots(x**3 + 2*x**2 + 4*x + 8, x, cubics=True) == \
{-2*I: 1, 2*I: 1, -2: 1}
assert roots((x**2 - x)*(x**3 + 2*x**2 + 4*x + 8), x) == \
{1: 1, 0: 1, -2: 1, -2*I: 1, 2*I: 1}
r1_2, r1_3 = Rational(1, 2), Rational(1, 3)
x0 = (3 * sqrt(33) + 19)**r1_3
x1 = 4 / x0 / 3
x2 = x0 / 3
x3 = sqrt(3) * I / 2
x4 = x3 - r1_2
x5 = -x3 - r1_2
assert roots(x**3 + x**2 - x + 1, x, cubics=True) == {
-x1 - x2 - r1_3: 1,
-x1 / x4 - x2 * x4 - r1_3: 1,
-x1 / x5 - x2 * x5 - r1_3: 1,
}
f = (x**2 + 2 * x + 3).subs({x: 2 * x**2 + 3 * x}).subs({x: 5 * x - 4})
r13_20, r1_20 = [Rational(*r) for r in ((13, 20), (1, 20))]
s2 = sqrt(2)
assert roots(f, x) == {
r13_20 + r1_20 * sqrt(1 - 8 * I * s2): 1,
r13_20 - r1_20 * sqrt(1 - 8 * I * s2): 1,
r13_20 + r1_20 * sqrt(1 + 8 * I * s2): 1,
r13_20 - r1_20 * sqrt(1 + 8 * I * s2): 1,
}
f = x**4 + x**3 + x**2 + x + 1
r1_4, r1_8, r5_8 = [Rational(*r) for r in ((1, 4), (1, 8), (5, 8))]
assert roots(f, x) == {
-r1_4 + r1_4 * 5**r1_2 + I * (r5_8 + r1_8 * 5**r1_2)**r1_2: 1,
-r1_4 + r1_4 * 5**r1_2 - I * (r5_8 + r1_8 * 5**r1_2)**r1_2: 1,
-r1_4 - r1_4 * 5**r1_2 + I * (r5_8 - r1_8 * 5**r1_2)**r1_2: 1,
-r1_4 - r1_4 * 5**r1_2 - I * (r5_8 - r1_8 * 5**r1_2)**r1_2: 1,
}
f = z**3 + (-2 - y) * z**2 + (1 + 2 * y - 2 * x**2) * z - y + 2 * x**2
assert roots(f, z) == {
1: 1,
Rational(1, 2) + y / 2 + sqrt(1 - 2 * y + y**2 + 8 * x**2) / 2: 1,
Rational(1, 2) + y / 2 - sqrt(1 - 2 * y + y**2 + 8 * x**2) / 2: 1,
}
assert roots(a * b * c * x**3 + 2 * x**2 + 4 * x + 8, x,
cubics=False) == {}
assert roots(a * b * c * x**3 + 2 * x**2 + 4 * x + 8, x, cubics=True) != {}
assert roots(x**4 - 1, x, filter='Z') == {1: 1, -1: 1}
assert roots(x**4 - 1, x, filter='R') == {1: 1, -1: 1}
assert roots(x**4 - 1, x, filter='I') == {I: 1, -I: 1}
pytest.raises(ValueError, lambda: roots(x**4 - 1, x, filter='spam'))
assert roots((x - 1) * (x + 1), x) == {1: 1, -1: 1}
assert roots((x - 1) * (x + 1), x, predicate=lambda r: r.is_positive) == {
1: 1
}
assert roots(x**4 - 1, x, filter='Z', multiple=True) == [-1, 1]
assert roots(x**4 - 1, x, filter='I', multiple=True) == [I, -I]
assert roots(x**3, x, multiple=True) == [0, 0, 0]
assert roots(1234, x, multiple=True) == []
f = x**6 - x**5 + x**4 - x**3 + x**2 - x + 1
assert roots(f) == {
-I * sin(pi / 7) + cos(pi / 7): 1,
-I * sin(2 * pi / 7) - cos(2 * pi / 7): 1,
-I * sin(3 * pi / 7) + cos(3 * pi / 7): 1,
I * sin(pi / 7) + cos(pi / 7): 1,
I * sin(2 * pi / 7) - cos(2 * pi / 7): 1,
I * sin(3 * pi / 7) + cos(3 * pi / 7): 1,
}
g = ((x**2 + 1) * f**2).expand()
assert roots(g) == {
-I * sin(pi / 7) + cos(pi / 7): 2,
-I * sin(2 * pi / 7) - cos(2 * pi / 7): 2,
-I * sin(3 * pi / 7) + cos(3 * pi / 7): 2,
I * sin(pi / 7) + cos(pi / 7): 2,
I * sin(2 * pi / 7) - cos(2 * pi / 7): 2,
I * sin(3 * pi / 7) + cos(3 * pi / 7): 2,
-I: 1,
I: 1,
}
r = roots(x**3 + 40 * x + 64)
real_root = [rx for rx in r if rx.is_extended_real][0]
cr = 108 + 6 * sqrt(1074)
assert real_root == -2 * root(cr, 3) / 3 + 20 / root(cr, 3)
eq = Poly((7 + 5 * sqrt(2)) * x**3 + (-6 - 4 * sqrt(2)) * x**2 +
(-sqrt(2) - 1) * x + 2,
x,
domain='EX')
assert roots(eq) == {-1 + sqrt(2): 1, -2 + 2 * sqrt(2): 1, -sqrt(2) + 1: 1}
eq = Poly(41 * x**5 + 29 * sqrt(2) * x**5 - 153 * x**4 -
108 * sqrt(2) * x**4 + 175 * x**3 + 125 * sqrt(2) * x**3 -
45 * x**2 - 30 * sqrt(2) * x**2 - 26 * sqrt(2) * x - 26 * x + 24,
x,
domain='EX')
assert roots(eq) == {
-sqrt(2) + 1: 1,
-2 + 2 * sqrt(2): 1,
-1 + sqrt(2): 1,
-4 + 4 * sqrt(2): 1,
-3 + 3 * sqrt(2): 1
}
eq = Poly(x**3 - 2 * x**2 + 6 * sqrt(2) * x**2 - 8 * sqrt(2) * x + 23 * x -
14 + 14 * sqrt(2),
x,
domain='EX')
assert roots(eq) == {
-2 * sqrt(2) + 2: 1,
-2 * sqrt(2) + 1: 1,
-2 * sqrt(2) - 1: 1
}
assert roots(Poly((x + sqrt(2))**3 - 7, x, domain='EX')) == \
{-sqrt(2) - root(7, 3)/2 - sqrt(3)*root(7, 3)*I/2: 1,
-sqrt(2) - root(7, 3)/2 + sqrt(3)*root(7, 3)*I/2: 1,
-sqrt(2) + root(7, 3): 1}
pytest.raises(PolynomialError, lambda: roots(x * y, x, y))
def test_exp2():
e1 = exp(cos(x)).series(x, 0)
assert e1 == E - E * x**2 / 2 + E * x**4 / 6 + O(x**6)
def test_sympyissue_11884():
assert O(x).subs({x: x - 1}) + 1 == 1 + O(x - 1, (x, 1))
assert cos(x).series(x, x0=1, n=1) == cos(1) + O(x - 1, (x, 1))
