# Symbolinen laskenta sympy-kirjastoa käyttäen

Tässä muistikirjassa käydään läpi Pythonin symbolisen laskennan sympy-kirjaston perusulottuvuuksia.


```python
import sympy
```


```python
z**2
```


```python
sympy.var('z') # esitellään muuttuja ensin
```




    z




```python
z**2 # nyt sillä voidaan laskea
```




    z**2




```python
True^True # ^ on varattu Pythonissa XOR-operaatiolle
```




    False




```python
True^False
```




    True




```python
z**(1/2) 
```




    z**0.5



Yllä Python laskee suluissa olevan jakolaskun ensin
ja siitä tulee Python-objekti ennen kuin SymPy ehtii muuttaa sen SymPyn olioksi.

Ratkaisu on käyttää sympify() tai Rational-luokkaa.


```python
z**(sympy.sympify(1)/2)
```




    sqrt(z)




```python
z**sympy.Rational(1/2)
```




    sqrt(z)



Esitellään muuttujia:


```python
from sympy import symbols
x, y, z = symbols('x y z')
u, v, w = symbols('u v w')
symbols('j0:7')
```




    (j0, j1, j2, j3, j4, j5, j6)




```python
g, h = symbols('h g')
```


```python
g
```




    h




```python
h
```




    g



Variables Assignment does not Create a Relation Between Expressions


```python
from sympy import Symbol
a=Symbol('a') # muuttujan a arvo a
```


```python
b=a+1 # muuttujan b arvo lauseke a+1
```


```python
print(b)
```

    a + 1



```python
a=4 # nyt a osoittaa kokonaislukuun 4, ei symboliin a
```


```python
print(a)
```

    4



```python
print(b) # b osoittaa lausekkeeseen, jonka arvo a+1
```

    a + 1



```python
from sympy.abc import p
```


```python
sympy.sqrt(p**2) # SymPy ei yksinkertaista tätä, koska vastauksena voi olla 1- tai 1
```




    sqrt(p**2)




```python
p=Symbol('p', positive=True) # nyt ratkaisu on yksikäsitteinen
```


```python
sympy.sqrt(p**2)
```




    p



Yhtäsuuruuden testausta, Eq, ==


```python
from sympy import symbols
x, y = symbols('x y')
sympy.Eq(x,y) # symbolinen yhtäsuuruus ilmaistaan Eq:lla
```




    Eq(x, y)




```python
(x-1)**2 == x**2-2*x+1 # == testaa symbolista samankaltaisuutta
```




    False




```python
(x-1)**2 == (x-1)**2 # == testaa symbolista samankaltaisuutta
```




    True



Semanttisen samankaltaisuuden testaamiseen vähennä lausekkeet toisistaan ja käytä expand, simplify. Muista myös trigsimp, powsimp, trigsimp, logcombine, radsimp, together


```python
from sympy import simplify
simplify((x-1)**2-(x**2-2*x+1))
```




    0




```python
from sympy import sin, cos, simplify, expand, powsimp, trigsimp, logcombine, radsimp, together
sinilauseke1 = sin(2*x)-2*sin(x)*cos(x)

```


```python
simplify(sinilauseke1)
```




    0




```python
expand(sinilauseke1, trig=True)
```




    0




```python
from sympy.abc import a,b
expand((a-b)**4) # lasketaan (a-b)^4
```




    a**4 - 4*a**3*b + 6*a**2*b**2 - 4*a*b**3 + b**4




```python
expand(2*x+3*y, complex=True) # otetaan kompleksiluvut käyttöön
```




    2*re(x) + 3*re(y) + 2*I*im(x) + 3*I*im(y)




```python
expand(cos(x+y)**2, trig=True) # otetaan trigonometriset funktiot käyttöön
```




    sin(x)**2*sin(y)**2 - 2*sin(x)*sin(y)*cos(x)*cos(y) + cos(x)**2*cos(y)**2




```python
expand(cos(x+2*y), trig=True)  # otetaan trigonometriset funktiot käyttöön
```




    -2*sin(x)*sin(y)*cos(y) + 2*cos(x)*cos(y)**2 - cos(x)




```python
simplify((x**3+y**2*x)/x) # lausekkeen sieventämistä
```




    x**2 + y**2




```python
from sympy import I
expand((4+3*I)**(4+3*I)) #lausekkeen sieventämistä
```




    336*I*(4 + 3*I)**(3*I) - 527*(4 + 3*I)**(3*I)



Harjoittele: laske (x-y)^4 ja sievennä sin(x)/cos(x)


```python
powsimp(x**a*x**b) #lasketaan potensseja
```




    x**(a + b)




```python
import pprint #pretty printing
pprint((3-x**(2*x)/(x+1)))
```


```python
together(x**6-17*x**4+8*x**2+5+3*x**5+22*x**3-8*x+6)
```




    x**6 + 3*x**5 - 17*x**4 + 22*x**3 + 8*x**2 - 8*x + 11




```python
together(1/a+1/b)
```




    (a + b)/(a*b)



Kuviot


```python
import matplotlib.pyplot
%matplotlib inline
```


```python
sympy.plot(sympy.sin(x))
```


```python
sympy.plot(sympy.sin(x)/x)
```


```python
sympy.plot(sympy.exp(-x)*sympy.sin(x**2), (x, 0, 1)) #tässä rajoitettiin aluetta
```


```python
sympy.plot(sympy.exp(2*x))
```


```python
sympy.plot(sympy.log(2/x))
```

Derivointi, differentiaalit ja integrointi


```python
from sympy import diff, exp
diff(cos(2*x),x)
```




    -2*sin(2*x)




```python
k = symbols('k', integer=True)
diff(exp(k*x),x)
```




    k*exp(k*x)




```python
from sympy import log
diff(log(1/x),x)
```




    -1/x



Korkeammat derivaatat


```python
diff(cos(2*x),x,3)
```




    8*sin(2*x)




```python
diff(exp(k*x),x,2)
```




    k**2*exp(k*x)




```python
from sympy import erf
diff(erf(x),x)
```




    2*exp(-x**2)/sqrt(pi)



Hyvä tapa on myös määritellä lausekkeita ja derivoida niitä:


```python
expr = x**2*sympy.sin(sympy.log(x))
```


```python
sympy.diff(expr,x)
```




    2*x*sin(log(x)) + x*cos(log(x))



Osittaiderivointi:


```python
expr2 = x*sympy.cos(y**2 + x)
```


```python
sympy.diff(expr2, x, 2, y, 3)
```




    4*y*(-2*x*y**2*sin(x + y**2) + 3*x*cos(x + y**2) + 4*y**2*cos(x + y**2) + 6*sin(x + y**2))



Määräämätön derivaatta:


```python
sympy.Derivative(expr2, x, 2, y, 3)
```




    Derivative(x*cos(x + y**2), (x, 2), (y, 3))




```python
sympy.Derivative(expr2, x, 2, y, 3).doit()
```




    4*y*(-2*x*y**2*sin(x + y**2) + 3*x*cos(x + y**2) + 4*y**2*cos(x + y**2) + 6*sin(x + y**2))



Integrointi:


```python
from sympy import integrate
integrate(5*x**5,x)
```




    5*x**6/6




```python
integrate(3*exp(3*x),x)
```




    exp(3*x)




```python
integrate(cos(x),x)
```




    sin(x)




```python
integrate(log(x),x)
```




    x*log(x) - x




```python
integrate(exp(-x**2)*erf(x), x)
```




    sqrt(pi)*erf(x)**2/4




```python
sympy.integrate(sympy.exp(-(x+y))*sympy.cos(x)*sympy.sin(y), x, y)
```




    -exp(-x)*exp(-y)*sin(x)*sin(y)/4 - exp(-x)*exp(-y)*sin(x)*cos(y)/4 + exp(-x)*exp(-y)*sin(y)*cos(x)/4 + exp(-x)*exp(-y)*cos(x)*cos(y)/4



Määritetään lauseke ja operoidaan sillä:


```python
integrand=sympy.log(x)**2
```


```python
sympy.integrate(integrand, x)
```




    x*log(x)**2 - 2*x*log(x) + 2*x



Sarjat:


```python
from sympy import series
series(cos(x), x)
```




    1 - x**2/2 + x**4/24 + O(x**6)




```python
series(erf(x),x)
```




    2*x/sqrt(pi) - 2*x**3/(3*sqrt(pi)) + x**5/(5*sqrt(pi)) + O(x**6)




```python
series(exp(x),x)
```




    1 + x + x**2/2 + x**3/6 + x**4/24 + x**5/120 + O(x**6)




```python
series(1/cos(x), x)
```




    1 + x**2/2 + 5*x**4/24 + O(x**6)



Sympy laskimena


```python
v, w, u = sympy.symbols('v, w, u')
n = sympy.symbols('n', interger=True)
from sympy import Mul, Pow, Rational, pi, N, oo
```


```python
Mul(3, Rational(2,4))
```




    3/2




```python
Mul(3, Rational(2,4), evaluate=False)
```




    3/2




```python
Pow(x*y,2)
```




    x**2*y**2




```python
Pow(x*y,2, evaluate=False)
```




    (x*y)**2




```python
pi*2
```




    2*pi




```python
exp(1)
```




    E




```python
pi.evalf()
```




    3.14159265358979




```python
pi.evalf(5)
```




    3.1416




```python
N(pi)
```




    3.14159265358979




```python
N(pi, 5)
```




    3.1416




```python
print(exp(1))
```

    E



```python
oo>999999999
```




    True




```python
oo/2
```




    oo



Laske 
- luvun kaksi neliöjuuri 50 desimaalilla,
- mikä on piin 26. desimaali,
- paljonko on luvun pi + e likiarvo.


Raja-arvot


```python
from sympy import limit, sin, exp, oo
limit(sin(x)/x,x,0)
```




    1




```python
limit(exp(x)/x, x, oo)
```




    oo




```python
limit((1+1/x)**x,x,oo)
```




    E



Määrätty intergraali:


```python
integrand=sympy.log(x)**2
```


```python
sympy.integrate(integrand, (x, 1, 10))
```




    -20*log(10) + 18 + 10*log(10)**2




```python
sympy.integrate(sympy.exp(-x), (x, 0, sympy.oo))
```




    1



Moninkertainen integraali:


```python
integrate(exp(-x**2-y**2),(x,-oo,oo),(y,-oo,oo))
```




    pi




```python
Voidaan myös luoda määräämätön Integral-objekti. Sen arvo voidaan laskea myöhemmin.
```


```python
sympy.Integral(integrand, (x, 1, 10))
```




    Integral(log(x)**2, (x, 1, 10))




```python
sympy.Integral(integrand, (x, 1, 10)).doit()
```




    -20*log(10) + 18 + 10*log(10)**2



Yhtälönratkaisu


```python
a, b, c, x = sympy.symbols(('a', 'b', 'c', 'x'))
```


```python
quadr_eq = sympy.Eq(a*x**2+b*x+c, 0)
```


```python
sympy.solve(quadr_eq)
```




    [{a: -(b*x + c)/x**2}]




```python
sympy.solve(quadr_eq, x)
```




    [(-b + sqrt(-4*a*c + b**2))/(2*a), -(b + sqrt(-4*a*c + b**2))/(2*a)]



Opetus: Jos ei muuta määritetä, sympy ratkaisee ensimmäisen symbolin suhteen.


```python
from sympy import solve
solve(x**4 - 1, x)
```




    [-1, 1, -I, I]




```python
solve(x**2+2*x-1,x)
```




    [-1 + sqrt(2), -sqrt(2) - 1]



Yllä olevat vastaukset hakasuluissa [] ovat listoja. Listat voivat sisältää erilaisia objekteja ja niitä voi muuttaa.


```python
from sympy import roots
roots(x**2+2*x-1,x)
```




    {-sqrt(2) - 1: 1, -1 + sqrt(2): 1}




```python
solve([x + 5*y - 2, -3*x + 6*y - 15], [x, y])
```




    {x: -3, y: 1}



Edellä olevat vastaukset taas ovat sanakirjoja. Ne ovat järjestämättömiä listoja ilman toistoja.

Huom. solve -> list, roots -> dictionary.


```python
solve(exp(x) + 1, x) #Eulerin lause, Eulerin identiteetti
```




    [I*pi]



Ratkaise yhtälö
(x-1)^4=4^4

Jatketaan yhtälön quadr_eq ratkaisemista:


```python
ratkaisut=sympy.solve(quadr_eq, x)
```


```python
xplus=ratkaisut[0]
xminus=ratkaisut[1]
```


```python
xplus_arvot=xplus.subs([(a,1),(b,2),(c,3)])
```


```python
xplus_arvot
```




    -1 + sqrt(2)*I




```python
Voidaan sijoittaa myös muita muuttujia:
```


```python
sympy.var('z0')
xminus_arvot=xminus.subs([(b,a), (c,a+z0)])
```


```python
xminus_arvot
```




    -(a + sqrt(a**2 - 4*a*(a + z0)))/(2*a)




```python
xminus_arvot.simplify()
```




    -(a + sqrt(-a*(3*a + 4*z0)))/(2*a)



Solveset on suositeltavin yhtälöiden ratkaisuun. Solveset kertoo kunkin ratkaisun vain kerran, moninkertaisuuden selvittämiseksi on hyvä käyttää funktiota roots:


```python
from sympy import solveset, roots
solveset(x**3-6*x**2+9*x,x)
```




    {0, 3}




```python
roots(x**3-6*x**2+9*x,x)
```




    {0: 1, 3: 2}



Huomaa vielä ero kahden seuraavan outputin kanssa.


```python
solveset(exp(x), x) # Yhtälöllä e^x = 0 ei ole ratkaisuja.
```




    EmptySet()




```python
solveset(cos(x)-x,x) # Tälle yhtälölle sympy ei löydä ratkaisua.
```




    ConditionSet(x, Eq(-x + cos(x), 0), Complexes(Reals x Reals, False))



Määritellään vielä funktioita:


```python
from sympy import Function
f, g = symbols('f g', cls=Function)
```


```python
f(x)
```




    f(x)




```python
f(x).diff(x)
```




    Derivative(f(x), x)



Tekijöihin jakoa:


```python
poly = x**4 - 3*x**2 + 1
```


```python
from sympy import factor
factor(poly)
```




    (x**2 - x - 1)*(x**2 + x - 1)




```python
factor(poly,modulus=5)
```




    (x - 2)**2*(x + 2)**2



Boolean lausekkeita


```python
from sympy import satisfiable
satisfiable(x & y)
```




    {x: True, y: True}





e53ee13591150405e32e19fe8545ea465b05baf2
ipynb
Jupyter Notebook
symbolinen-laskenta.ipynb
juhanurmonen/symbolinen-laskenta
a7936f96eca2ffe38ae1d93345cb4862e00ffd42
MIT
symbolinen-laskenta.ipynb
juhanurmonen/symbolinen-laskenta
a7936f96eca2ffe38ae1d93345cb4862e00ffd42
MIT
symbolinen-laskenta.ipynb
juhanurmonen/symbolinen-laskenta
a7936f96eca2ffe38ae1d93345cb4862e00ffd42
MIT
Qwen/Qwen-72B
1. YES
2. YES