Librăria Sympy

1. Importare:

import sympy as sp
sp.init_printing() # Pentru afisarea simbolurilor

2. Creare simboluri:

x = sp.Symbol(‘x’)
y = sp.Symbol(‘y’, real=True)

• Atribute ce trebuiesc specificate pentru anumite operații:

Argument Atribut
real, imaginary is_real, is_imaginary
positive, negative is_positive, is_negative
integer, odd, even is_integer, is_odd, is_even
prime is_prime
finite, infinite is_finite, is_infinite

ex:

x,y = sp.Symbols(“x,y”, positive=True)

sp.sqrt(x**2) # Se afiseaza x

3. Lucrul cu diferite tipuri de numere:

a) Întregi:
n = sp.Symbol(‘n’, integer=True)
n.is_integer # True
n.is_Integer # False

i = sp.Integer(19)
i.is_integer # True
i.is_Integer # True

• Factorialul unui număr:

sp.factorial(10) # Valoarea numerică

1
 sp.factorial(x) # Afiseaza x!

b) Reale:
sp.Float(0.3, 25) # 0.299999…
sp.Float(‘0.3’, 25) # 0.3

c) Raționale:
sp.Rational(11, 13) # 11/13
sp1 = sp.Rational(2,3)
sp2 = sp.Rational(4,5)
sp1 * sp2 # 8/15

4. Constante și caractere speciale

Π = sp.pi
e = sp.e
Y = sp.EulerGamma
i = sp.I
∞ = sp.oo

5. Funcții:

x,y,z = sp.symbols(“x,y,z”)
f = sp.Function(‘f’)
f(x) # f(x)
g = sp.Function(‘g’)(x,y,z)
g # g(x,y,z)
g.free_symbols # {x,y,z}

• Lambda:
h = sp.Lambda(x, x**2)
h # (x -> x^2)
h(5) # 25
h(1+x) # (1+x)^2

6. Expresii:

x = sp.Symbol(‘x’)
expr = x**2 + 1 + 3*x**3
expr # 3x^3 + 2x^2 + 1
expr.args # (1, 2x^2, 3x^3)
expr.args[1] # 2x^2

2
• Manipularea expresiilor:

a. Simplificarea

ex1:

expr = 2 * (x**2 – x) – x*(x+1)

expr # 2x^2 – x(x+1) – 2x
expr.simplify() # x(x-3)

ex2:

expr = 2 * sp.sin(x) * sp.cos(x)

expr # 2sin(x)cos(x)
expr.simplify() # sin(2x)

ex3:

expr = sp.exp(x) * sp.exp(y)

expr # exp(x)exp(y)
expr.simplify() # exp(x+y)

o Funcții de simplificare
sp.simplify()
sp.trigsimp()
sp.powsimp()
sp.combsimp()
sp.ratsimp()

b. Explicitarea

ex1:

expr = (x+1)*(x+2)
expr.expand() # x^2 + 3x + 2

ex2:

sp.sin(x+y).expand(trig= True) # sin(x)cos(y)+sin(y)cos(x)

ex3:

a,b = sp.symbols(“a,b”, positive=True)

sp.log(a*b).expand(log= True) # log(a) + log(b)

3
ex4:

sp.exp(I*a + b).expand(complex= True) #i(e^b)sin(a) +

(e^b)cos(a)

ex5:

sp.expand((a*b)**x, power_base=True) # a^x * b^x

ex6:

ep.exp((a-b)*x).expand(power_exp=True) # e^(iax)*e^(-ibx)

c. Factor comun:
sp.factor(x**2 -1) # (x-1)(x+)
sp.factor(x*sp.cos(x) + sp.sin(z) * x) # x(cos(x)+sin(z))

d. Factor comun pe un element:

expr = x + y + x*y*z
expr.collect(x) # x(yz + 1) + y

e. Combine:
sp.trigsimp()
sp.powsimp()
sp.logcombine()

ex:

sp.logcombine(sp.log(a) – sp.log(b)) # log(a/b)

f. Apart, Together, Cancel

sp.apart(1/(x**2 + 3*x + 2), x) # -1/(x+2) + 1/(x+1)
sp.together(1/(y*x +y) + 1/(1+x)) # (y+1)/y*(x+1)
sp.cancel(y/(y*x + y) # 1/(x+1)

g. Substituția:

ex1:

(x+y).subs(x,y) # 2y
sp.sin(x * sp.exp(x)).subs(x,y) # sin(y*e^y)

ex2:

expr = x*y + z**2*x

values = {x:1.25, y:0.4, z:3.2}
expr.subs(values) # 13.3
4
7. Evaluarea numerică:

ex1:

sp.N(1 + pi) # 4.1415…

sp.N(pi, 50) # 3.1415… (primele 50 de zecimale)
(x + 1/pi).evalf(10) # x + 0.318…

ex2:

expr = sp.sin(pi * x * sp.exp(x))

expr_func = sp.lambdiff(x, expr)
expr_func(1,0) # 0.773

8. Derivate

ex1:

f = sp.Function(‘f’)(x)
sp.diff(f,x) # d/dx f(x)
f.diff(x) # d/dx f(x)
sp.diff(f,x,x) # d^2/dx^2 f(x)
sp.diff(f,x,3) # d^3/dx^3 f(x)

ex2:

g = sp.Function(‘g’)(x,y)
g.diff(x,y) # ∂^2/ ∂x ∂y g(x,y)
g.diff(x,2,y,3) # ∂^5/ ∂x^3 ∂y^2 g(x,y)

ex3:

expr = x**4 + x**3 + x**2 + 1

expr.diff(x) # 4x^3 + 3x^2 + 2x + 1
expr.diff(x,x) # 2(6x^2 + 3x + 1)

ex4:

expr = (x+1)**3 * y**2 * 2*(z-1)

expr.diff(x,y,z) # 6y(x+1)^2

ex5:

d = sp.Derivative(sp.exp(sp.cos(x)), x)
d # d/dx e^(cos(x))
d.doit() # -e^(cos(x)) * sin(x)

5
9. Integrale

ex1:

a,b,x,y = sp.symbols(“a,b,x,y”)
f = sp.Function(‘f’)(x)
sp.integrate(f) # ∫ 𝑓(𝑥)𝑑𝑥
𝑎
sp.integrate(f,(x,a,b)) # ∫𝑏 𝑓(𝑥)𝑑𝑥

ex2:

sp.integrate(sp.sin(x)) # -cos(x)
sp.integrate(sp.sin(x),(x,a,b)) # cos(a) – cos(b)
sp.integrate(sp.ext(-x**2, (x,0,oo)) # √π/2

ex3:

expr = sp.sin(x * sp.exp(y))

sp.integrate(expr,x) # -e^y * cos(x*e^y)

expr = (x+y)**2
sp.integrate(expr,x) # (x^3)/3 + (x^2)*y * xy^2
sp.integrate(expr,x,y) # ((x^3)y)/3 + (x^2 y^2)/2 + (xy^3)/3
sp.integrate(expr, (x,0,1), (y,0,1)) # 7/6

10. Serii:

ex1:

x = sp.Symbol(‘x’)
f = sp.Function(‘f)(x)
sp.series(f,x) # Returneaza dezvoltarea seriei
x0 = sp.Symbol(‘x_0’)
f.series(x,x0,n=2) # Dezvoltarea pentru n=2
f.series(x,x0,n=2).remove() # Dezvoltarea pentru n=2 fara O()

ex2:

sp.series(sp.cos(x)) # 1 – (x^2)/2 + (x^4)/24 + O(x^6)

sp.series(sp.sin(x)) # x – (x^3)/6 + (x^5)/120 + O(x^6)
expr = sp.cos(x) / (1 + sp.sin(x*y))
expr.series(x, n=4) # 1 – xy + (x^2)*(y^2 – 1/2) + …
expr.series(y, n=4) # cox(x) – xycos(x) + …

6
11. Limite:

ex1:

sp.limit(sp.sin(x), x, 0) # 1
f = sp.Function(‘f’)
x, h = sp.symbols(“x, h”)
diff_limit = (f(x+h) – f(x)) / h
sp.limit(diff_limit.subs(f, sp.cos), h, 0) # -sin(x)

ex2:

expr = (x**2 – 3**x) / (2*x – 2)

p = sp.limit(expr/x, x, sp.oo)
q = sp.limit(expr – p*x, sp.oo)
p,q # (1/2, -1)

12. Sume și produse:

ex1:

n = sp.Symbol(‘n’, positive=True)
x = sp.Sum(1/(n**2), (n,1, oo)) # ∑𝑜𝑜 2
𝑛=1 1/(𝑛 )
x.doit() # (π^2)/6

ex2:

x = sp.Product(n, (n,1,7))
x # ∏7𝑛=1 𝑛
x.doit() # 5040

13. Ecuații:

ex1:

x = sp.Symbol(‘x’)
sp.solve(x**2 + 2*x -3) # [-3,1]

ex2:

a, b, c = sp.symbols(“a,b,c”)
sp.solve(a*x**2 + b*x +c, x) # [1/2a*(-b+√−4𝑎𝑐 + 𝑏^2), -1/2a*(b+
√−4𝑎𝑐 + 𝑏^2)]

7
ex3:

eq1 = x + 2*y – 1
eq2 = x – y + 1
sp.solve([eq1, eq2], [x,y], dict=True) # [{x: -1/3, y: 2/3}]

• Ecuații diferențiale:

ex:

d^2u/dx^2 + u(x)+1=0

u(0)=0; (du/dx)(1)=1
u = sympy.Function('u')
x = sympy.Symbol('x')
sympy.dsolve(
sympy.Derivative(u(x),x,x)
+u(x)+1,
u(x),
ics={
u(0): 0,
u(x).diff(x).subs(x,1): 1
}
) # u(x)= (sin(1)+1)sin(x)/cos(1) + cos(x) -1

14. Algebră liniară:

ex1:

1
sp.Matrix([1,2]) #
2
sp.Matrix([[1,2]]) # 1 2
0 1 2
sp.Matrix(3,3, lambda m,n : 10*m + n) # 10 11 12
20 21 22
ex2:

a,b,c,d = symbols(“a,b,c,d”)
M = sp.Matrix([
[a,b],
[c,d]
])

8
 2
M*M # [ 𝑎 + 𝑏𝑐 𝑎𝑏 + 𝑏𝑑 ]
𝑎𝑐 + 𝑐𝑑 𝑏𝑐 + 𝑑^2
x = sp.Matrix(sp.symbols(“x1,x2”))
𝑎𝑥1 𝑏𝑥2
M*x # [ ]
𝑐𝑥1 𝑑𝑥2
ex3:

p,q = sp.symbols(“p,q”)
M = sp.Matrix([
[1,p],
[q,1]
])
b = sp.Matrix(sp.symbols(“b1,b2”))
x = M.LUsolve(b)
𝑝(−𝑏1𝑞+𝑏2)
𝑏1 − −𝑝𝑞+1
x # [ ]
−𝑏1𝑞+𝑏2
−𝑝𝑞+1
x = M.inv() * b
𝑝𝑞 𝑏2𝑝
𝑏1 (−𝑝𝑞+1 + 1) − −𝑝𝑞+1
x # [ ]
𝑏1𝑞 𝑏2
− +
−𝑝𝑞+1 −𝑝𝑞+1

• Funcții specifice matrice:

Funcție Descriere
transpose/T transpusa matricei
adjoint/H adjuncta
trace urma matricei
det determinantul matricei
inv inversa matricei
LUdecomposition factorizarea LU a matricei
LUsolve rezolvare sistem de ecuatii cu
factorizarea LU
QRdecomposition factorizarea QR a matricei
diagonalize diagonalizarea matricei D=(P^-1)MP
norm norma matricei
rank rangul matricei
singular_values valorile singulare ale matricei
solve rezolva sistem de ecuatii