Hlavní navigace

Analýza funkcí s využitím knihovny SymPy

31. 5. 2022
Doba čtení: 25 minut

Sdílet

 Autor: Depositphotos
Ve třetím článku o knihovně SymPy určené pro provádění symbolických výpočtů v Pythonu se budeme zabývat především analýzou funkcí, tj. například hledáním singularit, globálních i lokálních minim a maxim, výpočtem limit funkce atd.

Obsah

1. Analýza funkcí s využitím knihovny SymPy

2. Explicitní a implicitní funkce

3. Výpočet singularit

4. Singularity pro funkce s komplexními nezávislými proměnnými

5. Zápis kladného a záporného nekonečna

6. Specifikace intervalů v knihovně SymPy

7. Funkce, která bude analyzována v rámci dalších kapitol

8. Výpočet lokálního minima

9. Výpočet lokálního maxima

10. Test, zda je funkce na zadaném intervalu rostoucí

11. Test, zda je funkce na zadaném intervalu klesající

12. První derivace funkce

13. Derivace podle různých proměnných

14. Derivace vyššího řádu počítané postupně

15. Derivace vyššího řádu počítaná v programové smyčce i úpravou parametrů funkce diff

16. Výpočet limity zprava i zleva

17. Výpočet limity v nevlastním bodě

18. Výsledek výpočtu limity funkce sin x-1 v nule

19. Repositář s demonstračními příklady

20. Odkazy na Internetu

1. Analýza funkcí s využitím knihovny SymPy

Se základními vlastnostmi knihovny SymPy jsme se již seznámili v předchozí dvojici článků [1] [2]. Připomeňme si, že jsme si prozatím ukázali například způsob zápisu výrazů (včetně funkcí) v SymPy, úpravy zapsaných výrazů, hledání kořenů polynomů, faktorizaci polynomů a v neposlední řadě taktéž symbolickou derivaci a integraci. Taktéž jsme si ukázali, jakým způsobem je možné integrovat SymPy do Jupyter Notebooku i to, jak lze vykreslit průběh funkcí přímo na plochu diáře (notebooku).

Obrázek 1: Zobrazení výrazu zpracovatelného knihovnou SymPy v Jupyter Notebooku.

Na výše zmíněnou dvojici článků dnes navážeme. Zabývat se totiž budeme především analýzou funkcí, což znamená, že budeme hledat singularity, globální i lokální minima a maxima, vypočteme limity funkce (zleva či zprava), ukážeme si, jak se zjistí, zda je funkce na nějakém intervalu rostoucí, klesající, monotonní atd. Navíc si budeme muset ukázat i některé další techniky, například způsob zápisu intervalů.

Obrázek 2: Vykreslení průběhu funkce.

2. Explicitní a implicitní funkce

Na tomto místě je vhodné se zmínit o tom, jakým způsobem je možné funkce (pro jednoduchost funkce s jedinou nezávislou proměnnou, popř. se dvěma proměnnými) reprezentovat. Typicky se setkáme s explicitním zápisem funkce ve tvaru y=f(x), což je způsob zápisu plně podporovaný knihovnou SymPy.

Obrázek 3: Explicitně zapsanou funkcí lze popsat například takzvaná „řetězovka“, což je křivka důležitá v praxi (stavebnictví atd.).

Tento popis funkce je sice nejjednodušší a umožňuje mj. popsat jak (některé) křivky algebraické, tak i křivky transcendentní, ovšem není možné ho použít například ve chvíli, kdy křivka obsahuje dva či více bodů ležících přímo nad sebou. Příkladem jsou jak obecně umístěné kuželosečky, tak i například spirály. V případě kuželoseček se tento problém může řešit tak, že funkce f představuje jen polovinu kuželosečky – ovšem výsledná reprezentace již nedokáže popsat plynulý pohyb bodu po kuželosečce (či obecně po křivce).

Obrázek 4: Logaritmická spirála, kterou nelze popsat explicitní funkcí, podobně jako jimi nelze popsat například kuželosečky.

Kromě zápisu explicitní funkce je možné použít funkci implicitní, která se zapisuje ve tvaru:

F(x,y)=0

V porovnání s předchozím popisem je popis implicitní funkcí obecnější, neboť s jeho využitím můžeme reprezentovat křivky obsahující několik samostatných cest apod. Následuje příklad implicitní funkce popisující mj. i všechny kuželosečky (záleží pouze na výběru koeficientů A až F):

Ax2+Bxy+Cy2+Dx+Ey+F=0

Poznámka: mimochodem – v tomto případě se jedná o algebraické křivky, neboť je lze popsat polynomem, a to jak v parametrické podobě, tak i v případě implicitní funkce. Mnohé křivky ovšem pouze s využitím polynomů vyjádřit nelze. Tyto křivky nazýváme transcendentní.

V dnešním článku se budeme zabývat převážně explicitně zapsanými funkcemi, a to navíc funkcemi s jedinou nezávislou proměnnou, i když knihovna SymPy podporuje i implicitní funkce.

3. Výpočet singularit

Při analýze vlastností funkcí je mnohdy důležité zjistit i případné singularity. K tomuto účelu slouží funkce nazvaná příhodně singularity:

Help on function singularities in module sympy.calculus.singularities:
 
singularities(expression, symbol)
    Find singularities of a given function.
 
    Parameters
    ==========
 
    expression : Expr
        The target function in which singularities need to be found.
    symbol : Symbol
        The symbol over the values of which the singularity in
        expression in being searched for.
 
    Returns
    =======
 
    Set
        A set of values for ``symbol`` for which ``expression`` has a
        singularity. An ``EmptySet`` is returned if ``expression`` has no
        singularities for any given value of ``Symbol``.
Poznámka: oficiální popis funkce singularity je dostupný na stránce https://docs.sympy.org/la­test/modules/calculus/index­.html#sympy.calculus.singu­larities.singularities.

Vyzkoušejme si nyní výpočet singularit pro jednoduchou funkci 1/(x2-1), pro níž lze singularity snadno vypočítat ručně – zjištěním, pro které hodnoty je jmenovatel roven nule:

from sympy import singularities, symbols, pprint
 
a, b, c, d, e, x = symbols('a,b,c,d,e,x')
 
f = 1/(x**2 - 1)
 
pprint(f)
 
print()
 
s = singularities(f, x)
pprint(s)

Výsledkem je množina dvou hodnot –1 a 1:

  1
──────
 2
x  - 1
 
{-1, 1}
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy44.py.

Zajímavější bude výpočet singularit pro zlomek, v jehož jmenovateli je periodická funkce sin:

from sympy import singularities, symbols, pprint, sin
 
a, b, c, d, e, x = symbols('a,b,c,d,e,x')
 
f = 1/(sin(x))
 
pprint(f)
 
print()
 
s = singularities(f, x)
pprint(s)

Nyní je výsledkem výpočtu nekonečná (ovšem spočetná) množina:

  1
──────
sin(x)
 
{2⋅n⋅π │ n ∊ ℤ} ∪ {2⋅n⋅π + π │ n ∊ ℤ}
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy45.py.

4. Singularity pro funkce s komplexními nezávislými proměnnými

U některých funkcí nastávají singularity v případě, že vstupem je komplexní číslo. Příkladem je následující kubická funkce:

from sympy import singularities, symbols, pprint
 
a, b, c, d, e, x = symbols('a,b,c,d,e,x')
 
f = 1/(x**3 - x**2 + x)
 
pprint(f)
 
print()
 
s = singularities(f, x)
pprint(s)

S výsledky:

     1
───────────
 3    2
x  - x  + x
 
⎧   1   √3⋅ⅈ  1   √3⋅ⅈ⎫
⎨0, ─ - ────, ─ + ────⎬
⎩   2    2    2    2  ⎭
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy47.py.

Popř. následující funkce:

from sympy import singularities, symbols, pprint, sin
 
a, b, c, d, e, x = symbols('a,b,c,d,e,x')
 
f = 1/(sin(x)-x**2)
 
pprint(f)
 
print()
 
s = singularities(f, x)
pprint(s)

Nyní bude výsledek vypadat následovně:

      1
─────────────
   2
- x  + sin(x)
 
⎧  │         ⎛   2             ⎞⎫
⎨x │ x ∊ ℂ ∧ ⎝- x  + sin(x) = 0⎠⎬
⎩  │                            ⎭
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy46.py.

5. Zápis kladného a záporného nekonečna

V navazujících kapitolách si ukážeme, jakým způsobem se v knihovně SymPy počítají lokální minima a maxima, jak se na intervalu zjišťuje monotonnost funkce apod. Všechny tyto výpočty mohou probíhat buď nad celým definičním oborem funkce (což je typicky obor reálných čísel, ovšem může se jednat i o čísla komplexní atd.) nebo nad určeným intervalem. A právě způsobem zápisu intervalů se budeme zabývat v této kapitole.

Interval je specifikován dvojicí hodnot od-do. V matematice je ovšem nutné přesně specifikovat, jestli mezní hodnoty do intervalu spadají či nikoli (dokonce je možné, aby jedna z hodnot do intervalu spadala a druhá ne). Navíc je nutné umět definovat intervaly typu „od záporného nekonečna do nuly (včetně)“ či dokonce „od záporného nekonečna ke (kladnému) nekonečnu“. Všechny tyto varianty jsou knihovnou SymPy pochopitelně podporovány.

Začněme tím, jakým způsobem lze reprezentovat kladné a záporné nekonečno. Pro tento účel slouží symbol pojmenovaný oo (nebo též S.Infinity), který lze naimportovat a ihned začít používat. Symbol samotný reprezentuje kladné nekonečno, ovšem nic nám pochopitelně nebrání v použití unárního operátoru - pro zápis nekonečna záporného:

Help on Infinity in module sympy.core.numbers object:
 
class Infinity(Number)
 |  Positive infinite quantity.
 |
 |  In real analysis the symbol `\infty` denotes an unbounded
 |  limit: `x\to\infty` means that `x` grows without bound.
 |
 |  Infinity is often used not only to define a limit but as a value
 |  in the affinely extended real number system.  Points labeled `+\infty`
 |  and `-\infty` can be added to the topological space of the real numbers,
 |  producing the two-point compactification of the real numbers.  Adding
 |  algebraic properties to this gives us the extended real numbers.
 |
 |  Infinity is a singleton, and can be accessed by ``S.Infinity``,
 |  or can be imported as ``oo``.
 ...
 ...
 ...
Poznámka: pravděpodobně je zřejmé, proč byl vybrán zrovna symbol oo – podobá se totiž zápisu skutečného nekonečna jako ležaté osmičky.

Obrázek 5: Takto se kladné a záporné nekonečno zobrazí v Jupyter Notebooku.

6. Specifikace intervalů v knihovně SymPy

Interval je v knihovně SymPy reprezentován instancí třídy Interval:

Help on class Interval in module sympy.sets.sets:
 
class Interval(Set, sympy.core.evalf.EvalfMixin)
 |  Represents a real interval as a Set.
 |
 |  Usage:
 |      Returns an interval with end points "start" and "end".
 |
 |      For left_open=True (default left_open is False) the interval
 |      will be open on the left. Similarly, for right_open=True the interval
 |      will be open on the right.
 ...
 ...
 ...

Nyní si ukažme, jak se zapisují různé varianty intervalů, tedy intervaly otevřené/uzavřené zprava či zleva. V matematice je typ intervalu zvolen použitým symbolem při zápisu: (, ), < a >, což je však v případě knihovny SymPy poněkud komplikované, neboť tato knihovna je postavena nad programovacím jazykem Python a je tedy omezena jeho syntaxí (a do určité míry i sémantikou). Z tohoto důvodu je nutné intervaly zapisovat formou funkce (či – chcete-li – konstruktoru) a to následujícími způsoby:

Obrázek 6: Zápisy různých variant intervalů. Povšimněte si, jak se určuje, zda je interval zleva/zprava otevřený či naopak uzavřený.

Poznámka: v případě kladného i záporného nekonečna je interval pochopitelně otevřený.

7. Funkce, která bude analyzována v rámci dalších kapitol

V navazujících kapitolách se budeme zabývat analýzou jednoduché kubické funkce zapsané ve tvaru x3-2×2. Průběh této funkce je zajímavý především v okolí nuly (resp. přesněji řečeno zhruba v intervalu ← 2,2>, neboť se zde nachází lokální maximum, lokální minimum a navíc (resp. tudíž) je funkce nejprve rostoucí, potom klesající a posléze dále rostoucí). Právě s využitím této jednoduché kubické funkce a již zmíněného intervalu si můžeme ukázat základní vlastnosti funkcí pro zjištění lokálních maxim, minim, monotonnosti atd. (povšimněte si, že jsou zvoleny konkrétní koeficienty, neboť v opačném případě by nebylo možné korektně provést všechny analýzy).

Obrázek 7: Průběh zkoumané funkce zhruba v intervalu ← 2,2>, tedy v oblasti okolo počátku souřadné soustavy.

Poznámka: teoreticky by bylo možné použít i „zajímavější“ funkci typu sinc, tedy sin(x)/x, ovšem ne všechny výpočty a analýzy nad touto funkcí jsou knihovnou SymPy podporovány. Proto byla zvolena mnohem jednodušší funkce.

Obrázek 8: Zobrazení průběhu zkoumané funkce v Jupyter Notebooku.

8. Výpočet lokálního minima

Poměrně často se setkáme s požadavkem na zjištění globálního či lokálního minima a/nebo maxima. I tento typ výpočtu je pro některé funkce v knihovně SymPy implementován. Pro zjištění globálního minima nebo maxima se nemusí specifikovat interval, ale pro lokální minima a maxima to pochopitelně nutné je.

Obrázek 9: Lokální minimum a maximum lze najít i na průběhu derivované funkce – konkrétně v bodech, kde derivovaná funkce prochází osou x.

Ukažme si tedy, jak se vypočte lokální minimum zkoumané funkce ve dvou různých intervalech:

from sympy import symbols, pprint, init_printing
from sympy import Interval, minimum, S
 
init_printing(use_unicode=True)
 
x = symbols('x')
 
f = x**3 - 2*x**2
 
pprint(f)
 
print()
 
print(minimum(f, x, Interval(-2, 2)))
print(minimum(f, x, Interval(-1, 1)))

Na prvním intervalu je zjištěno minimum –16, na užším intervalu pak –3:

 3      2
x  - 2⋅x
 
-16
-3
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy48.py.

9. Výpočet lokálního maxima

Naprosto stejným postupem můžeme vypočítat i lokální maxima. Pochopitelně se pro tento účel použije odlišná funkce pojmenovaná maximum, jejíž základní vlastnosti jsou však stejné, jako u funkce minimum.

from sympy import symbols, pprint, init_printing
from sympy import Interval, maximum, S
 
init_printing(use_unicode=True)
 
x = symbols('x')
 
f = x**3 - 2*x**2
 
pprint(f)
 
print()
 
print(maximum(f, x, Interval(-2, 2)))
print(maximum(f, x, Interval(-1, 1)))

Nyní s výsledky:

 3      2
x  - 2⋅x
 
0
0
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy49.py.

10. Test, zda je funkce na zadaném intervalu rostoucí

V mnoha případech nás mohou zajímat i další vlastnosti funkcí. Typicky se jedná o test na monotonnost, tedy zjištění, jestli je funkce ve zvoleném intervalu stále rostoucí nebo stále klesající. Popř. můžeme chtít zjistit, zda je funkce na zvoleném intervalu rostoucí nebo klesající (což je specifičtější test, než test na monotonnost). I tento typ analýzy je v knihovně SymPy dostupný, i když i zde platí, že ne všechny typy funkcí lze tímto způsobem zpracovat resp. analyzovat. První funkcí z této oblasti je funkce nazvaná jednoduše is_increasing. Ta slouží pro zjištění, zda analyzovaná funkce na zvoleném intervalu roste či nikoli. Ukažme si nyní příklad použití této funkce:

from sympy import symbols, pprint, init_printing
from sympy import Interval, is_increasing
 
init_printing(use_unicode=True)
 
x = symbols('x')
 
f = x**3 - 2*x**2
 
pprint(f)
 
print()
 
i1 = Interval(-2, 2)
i2 = Interval(-2, 0)
i3 = Interval(0, 1)
i4 = Interval(1.5, 4)
 
print(i1, is_increasing(f, i1, x))
print(i2, is_increasing(f, i2, x))
print(i3, is_increasing(f, i3, x))
print(i4, is_increasing(f, i4, x))

Povšimněte si, že funkce je rostoucí na intervalu ← 2, 2> a taktéž <1.5, 4>:

 3      2
x  - 2⋅x
 
Interval(-2, 2) None
Interval(-2, 0) True
Interval(0, 1) False
Interval(1.50000000000000, 4) True
Poznámka: None se v pravdivostních operacích vyhodnocuje na nepravdu, stejně jako False.
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy50.py.

Totéž lze pochopitelně provést i pro otevřené intervaly:

from sympy import symbols, pprint, init_printing
from sympy import Interval, is_increasing, oo
 
init_printing(use_unicode=True)
 
x = symbols('x')
 
f = x**3 - 2*x**2
 
pprint(f)
 
print()
 
i1 = Interval(-oo, 2)
i2 = Interval(-oo, 0)
i3 = Interval(0, 1)
i4 = Interval(1.5, oo)
 
print(i1, is_increasing(f, i1, x))
print(i2, is_increasing(f, i2, x))
print(i3, is_increasing(f, i3, x))
print(i4, is_increasing(f, i4, x))

Tentokrát s výsledky:

 3      2
x  - 2⋅x
 
Interval(-oo, 2) None
Interval(-oo, 0) True
Interval(0, 1) False
Interval(1.50000000000000, oo) True
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy52.py.

11. Test, zda je funkce na zadaném intervalu klesající

Vzhledem k existenci výše popsané funkce is_increasing nás nepřekvapí fakt, že existuje funkce pojmenovaná is_decreasing. Tato funkce vrátí pravdivostní hodnotu s informací o tom, zda je nějaká funkce na specifikovaném intervalu klesající či nikoli (což ovšem neznamená, že je rostoucí):

from sympy import symbols, pprint, init_printing
from sympy import Interval, is_decreasing
 
init_printing(use_unicode=True)
 
x = symbols('x')
 
f = x**3 - 2*x**2
 
pprint(f)
 
print()
 
i1 = Interval(-2, 2)
i2 = Interval(-2, 0)
i3 = Interval(0, 1)
i4 = Interval(1.5, 4)
 
print(i1, is_decreasing(f, i1, x))
print(i2, is_decreasing(f, i2, x))
print(i3, is_decreasing(f, i3, x))
print(i4, is_decreasing(f, i4, x))

Podívejme se nyní na výsledky vypsané tímto příkladem:

 3      2
x  - 2⋅x
 
Interval(-2, 2) False
Interval(-2, 0) False
Interval(0, 1) True
Interval(1.50000000000000, 4) False

12. První derivace funkce

Vraťme se ještě krátce k úvodnímu článku, v němž jsme si kromě dalších důležitých informací řekli i to, že knihovna SymPy podporuje symbolickou derivaci zvoleného výrazu (a tedy i funkce, minimálně funkce zapsané explicitně). Pro provedení derivace slouží funkce nazvaná diff, které se předá jak derivovaný výraz, tak i proměnná (proměnné), podle kterých se bude derivovat. V případě explicitně zadané funkce s jednou nezávislou proměnnou x tedy můžeme psát:

diff1 = diff(funkce, x)
pprint(diff1)
Poznámka: oficiální popis funkce diff je dostupný na stránce https://docs.sympy.org/la­test/modules/core.html?hig­hlight=diff#sympy.core.fun­ction.diff.

Vyzkoušejme si nyní zderivovat složitější funkci, konkrétně polynom doplněný o člen tvořený reciprokou funkci – nepřímou úměrou:

from sympy import diff, symbols, pprint
 
x = symbols('x')
 
f = 5*x**3 + 4*x**2 + 3*x + 4 + 1/x
 
pprint(f)
 
print()
 
diff1 = diff(f, x)
pprint(diff1)

Po spuštění skriptu se nejdříve vypíše původní funkce a následně i její derivace:

   3      2             1
5⋅x  + 4⋅x  + 3⋅x + 4 + ─
                        x
 
    2             1
15⋅x  + 8⋅x + 3 - ──
                   2
                  x
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy38.py.

Namísto číselných konstant pochopitelně můžeme použít symbolické konstanty – i v tomto případě lze derivaci vypočítat:

from sympy import diff, symbols, pprint
 
a, b, c, d, e, x = symbols('a,b,c,d,e,x')
 
f = a*x**3 + b*x**2 + c*x + d + e/x
 
pprint(f)
 
print()
 
diff1 = diff(f, x)
pprint(diff1)

Výsledky – původní funkce i její derivace:

   3      2             e
a⋅x  + b⋅x  + c⋅x + d + ─
                        x
 
     2               e
3⋅a⋅x  + 2⋅b⋅x + c - ──
                      2
                     x
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy39.py.

13. Derivace podle různých proměnných

Derivaci je možné vypočítat (vyjádřit) různě na základě toho, podle jaké proměnné se má derivace vypočítat. Tento koncept, s nímž jsme se v krátkosti seznámili již v úvodním článku, si můžeme ukázat na příkladu funkce se třemi nezávislými proměnnými x, y a z (opět se jedná o polynom zkombinovaný s reciprokou funkcí):

from sympy import diff, symbols, pprint
 
x, y, z, w = symbols('x, y, z, w')
 
f = 4*x**2 + 3*y**2 + 1/z
 
pprint(f)
 
print()
 
diff1 = diff(f, x)
pprint(diff1)
 
print()
 
diff2 = diff(f, y)
pprint(diff2)
 
print()
 
diff3 = diff(f, z)
pprint(diff3)
 
print()
 
diff4 = diff(f, w)
pprint(diff4)

Původní funkce je skriptem vypsána v tomto tvaru:

   2      2   1
4⋅x  + 3⋅y  + ─
              z

První derivace podle proměnné x:

8⋅x

První derivace podle proměnné y:

6⋅y

První derivace podle proměnné z:

-1
───
  2
 z

První derivace podle proměnné w (ta se ve funkci nikde nevyskytuje a proto je výsledkem nula):

0
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy40.py.

Podobný příklad, který ovšem namísto numerických konstant používá symbolické konstanty:

from sympy import diff, symbols, pprint
 
a, b, c, d, e, x, y, z, w = symbols('a, b, c, d, e, x, y, z, w')
 
f = a*x**b + c*y**d + e/z
 
pprint(f)
 
print()
 
diff1 = diff(f, x)
pprint(diff1)
 
print()
 
diff2 = diff(f, y)
pprint(diff2)
 
print()
 
diff3 = diff(f, z)
pprint(diff3)
 
print()
 
diff4 = diff(f, w)
pprint(diff4)

Původní funkce je skriptem vypsána v tomto tvaru:

   b      d   e
a⋅x  + c⋅y  + ─
              z

První derivace podle proměnné x:

     b
a⋅b⋅x
──────
  x

První derivace podle proměnné y:

     d
c⋅d⋅y
──────
  y

První derivace podle proměnné z:

-e
───
  2
 z

První derivace podle proměnné w (ta se ve funkci nikde nevyskytuje a proto je výsledkem nula):

0
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy41.py.

14. Derivace vyššího řádu počítané postupně

V případě, že je nutné vypočítat derivace vyšších řádů, můžeme postupovat dvěma způsoby. První způsob je založen na opakovaném provádění derivace (tedy volání funkce diff) – výsledkem jedné derivace je funkce, z níž se vypočte derivace o řád vyšší atd. atd. Jedná se o způsob, který však není příliš čitelný a již vůbec ne stručný:

from sympy import diff, symbols, pprint
 
a, b, c, d, e, x = symbols('a,b,c,d,e,x')
 
f = a*x**3 + b*x**2 + c*x + d + e/x
 
pprint(f)
 
print()
 
diff1 = diff(f, x)
pprint(diff1)
print()
 
diff2 = diff(f, x, x)
pprint(diff2)
print()
 
diff3 = diff(f, x, x, x)
pprint(diff3)
print()
 
diff4 = diff(f, x, x, x, x)
pprint(diff4)

Výsledky: nejdříve původní funkce:

   3      2             e
a⋅x  + b⋅x  + c⋅x + d + ─
                        x

První derivace původní funkce:

     2               e
3⋅a⋅x  + 2⋅b⋅x + c - ──
                      2
                     x

Druhá derivace původní funkce:

  ⎛            e ⎞
2⋅⎜3⋅a⋅x + b + ──⎟
  ⎜             3⎟
  ⎝            x ⎠

Třetí derivace původní funkce:

  ⎛    e ⎞
6⋅⎜a - ──⎟
  ⎜     4⎟
  ⎝    x ⎠

Čtvrtá derivace původní funkce:

24⋅e
────
  5
 x

Z výsledků je patrné, jak se postupně snižuje stupeň polynomu a současně roste mocnina jmenovatele ve zlomku (konstantní členy jsou při derivování odstraněny zcela).

Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy42.py.

15. Derivace vyššího řádu počítaná v programové smyčce i úpravou parametrů funkce diff

Otrocký postupný zápis výpočtů derivací vyšších řádů lze pochopitelně nahradit programovou smyčkou, v níž vždy vypočteme derivaci z funkce získané v předchozí iteraci. Počet opakování smyčky bude odpovídat řádu (poslední) vypsané derivace. Zápis takové programové smyčky v Pythonu je snadný:

from sympy import diff, symbols, pprint
 
a, b, c, d, e, x = symbols('a,b,c,d,e,x')
 
f = a*x**3 + b*x**2 + c*x + d + e/x
 
pprint(f)
 
print()
 
for d in range(5):
    diff1 = diff(f, x)
    pprint(diff1)
    f = diff1
    print()

Výsledky získané po spuštění tohoto skriptu jsou zpočátku stejné, jako tomu bylo u demonstračního příkladu popsaného v předchozí kapitole:

   3      2             e
a⋅x  + b⋅x  + c⋅x + d + ─
                        x
 
     2               e
3⋅a⋅x  + 2⋅b⋅x + c - ──
                      2
                     x
 
              2⋅e
6⋅a⋅x + 2⋅b + ───
                3
               x
 
      6⋅e
6⋅a - ───
        4
       x
 
24⋅e
────
  5
 x
 
-120⋅e
───────
    6
   x
Poznámka: úplný zdrojový kód tohoto demonstračního příkladu je dostupný na adrese https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy43.py.

Pokud pouze potřebujeme získat n-tou derivaci, je možné použít tento způsob výpočtu:

dfn = diff(f, x, x, x...)

kde počet opakování parametru x odpovídá řádu derivace.

16. Výpočet limity zprava i zleva

Podívejme se nyní na graf s průběhem funkce x-1 v okolí počátku souřadné soustavy:

Obrázek 10: Průběh funkce x-1 nám nabízí hned několik vhodných bodů pro výpočet limit.

Pro vstup x=0 není funkce definována, ovšem můžeme vypočítat limitu zprava i zleva pro x blížící se k nule. Výpočet limity je realizován funkcí nazvanou limit, které se předává jak analyzovaná funkce, tak i jméno nezávislé proměnné, pro kterou je limita počítána. Třetím parametrem je vlastní či nevlastní bod, pro nějž je výpočet prováděn a čtvrtý parametr, který je volitelný, určuje, zda se počítá limita zprava či limita zleva – v tomto parametru specifikujeme řetězec „+“ pro limitu zprava a „-“ pro limitu zleva (u některých funkcí není nutné tento parametr uvádět).

Zkusme tedy vypočítat limitu zprava pro x→0:

from sympy import *
 
x = symbols('x')
f = 1/x
 
pprint(limit(f, x, 0, '+'))

Výsledkem je kladné nekonečno, což odpovídá chování funkce:

Nyní vypočtěme limitu zleva pro x→0:

from sympy import *
 
x = symbols('x')
f = 1/x
 
pprint(limit(f, x, 0, '-'))

Výsledkem je (podle očekávání) záporné nekonečno:

-∞

17. Výpočet limity v nevlastním bodě

Vzhledem k tomu, že již víme, jak v knihovně SymPy reprezentovat nekonečno (symbolem oo), můžeme si vyzkoušet výpočet limity v nevlastním bodě. Nejprve pro kladné nekonečno:

from sympy import *
 
x = symbols('x')
f = 1/x
 
pprint(limit(f, x, oo))

Výsledkem bude (opět podle očekávání) nula:

0

Výpočet limity pro záporné nekonečno:

from sympy import *
 
x = symbols('x')
f = 1/x
 
pprint(limit(f, x, -oo))

V tomto případě bude opět výsledkem nula, i když se k ní funkce přibližuje směrem od záporných hodnot:

0

18. Výsledek výpočtu limity funkce y=sin x-1 v nule

U některých funkcí může být výpočet limity složitější, než tomu bylo u jednoduché nepřímé úměrnosti. Příkladem může být funkce y = sin x-1, která v okolí nuly nemá přesně definovanou limitu (pro x→0 se frekvence „sinusovky“ zvyšuje nade všechny meze). Jak tedy bude vypadat výsledek výpočtu? Podívejme se na další příklad:

Linux tip

from sympy import *
 
x = symbols('x')
f = sin(1/x)
 
pprint(limit(f, x, 0, '+'))

SymPy odpoví, že limitou jsou hodnoty v intervalu mezi –1 a 1, což je asi nejblíže pravdě:

<-1, 1>

19. Repositář s demonstračními příklady

Zdrojové kódy všech prozatím popsaných demonstračních příkladů určených pro programovací jazyk Python 3 byly uloženy do Git repositáře dostupného na adrese https://github.com/tisnik/most-popular-python-libs. V případě, že nebudete chtít klonovat celý repositář (ten je ovšem stále velmi malý, dnes má velikost zhruba několik desítek kilobajtů), můžete namísto toho použít odkazy na jednotlivé příklady, které naleznete v následující tabulce:

# Demonstrační příklad Stručný popis příkladu Cesta
1 sympy01.py zjednodušování konstantního výrazu s odmocninou https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy01.py
2 sympy02.py zjednodušování konstantních výrazů https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy02.py
3 sympy03.py čitelný výpis výrazů funkcí sympy.pprint https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy03.py
4 sympy04.py čitelný výpis výrazů funkcí sympy.pprint, složitější výsledky https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy04.py
5 sympy05.py deklarace a „terminálový“ výpis jednoduchého výrazu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy05.py
6 sympy06.py deklarace a „matematický“ výpis jednoduchého výrazu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy06.py
7 sympy07.py výraz s větším množstvím proměnných (zlomek) https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy07.py
8 sympy08.py výraz s větším množstvím proměnných (zlomek) https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy08.py
9 sympy09.py zjednodušení výrazu s jedinou proměnnou https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy09.py
10 sympy10.py zjednodušení výrazu se třemi proměnnými a se zlomky https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy10.py
11 sympy11.py pokus o použití nedefinované proměnné https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy11.py
12 sympy12.py výraz x2-y2 https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy12.py
13 sympy13.py složitější výraz s několika členy https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy13.py
14 sympy14.py faktorizace výrazu x2-y2 https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy14.py
15 sympy15.py faktorizace výrazu x2-2× + 1 https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy15.py
16 sympy16.py expanze výrazu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy16.py
17 sympy17.py expanze (roznásobení závorek) složitějšího výrazu se dvěma proměnnými https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy17.py
18 sympy18.py expanze (roznásobení závorek) složitějšího výrazu se třemi proměnnými https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy18.py
19 sympy19.py řešení kvadratické rovnice https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy19.py
20 sympy20.py řešení kvadratické rovnice, odlišná forma výstupu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy20.py
21 sympy21.py řešení kvadratické rovnice se dvěma neznámými https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy21.py
22 sympy22.py výpočet derivace polynomu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy22.py
23 sympy23.py výpočet derivace složitějšího výrazu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy23.py
24 sympy24.py výpočet integrace polynomu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy24.py
25 sympy25.py výpočet integrace složitějšího polynomu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy25.py
       
26 sympy26.py symboly vs. proměnné https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy26.py
27 sympy27.py reálné kořeny kvadratické rovnice https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy27.py
28 sympy28.py komplexní kořeny kvadratické rovnice https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy28.py
29 sympy29.py hledání kořenů kubické rovnice https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy29.py
30 sympy30.py kořeny polynomů vyšších stupňů https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy30.py
31 sympy31.py průchod nulovými body periodické funkce https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy31.py
32 sympy32.py vyhledání všech možných řešení https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy32.py
33 sympy33.py vyhledání řešení pro funkci sinc https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy33.py
34 sympy34.py řešení nerovnosti https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy34.py
35 sympy35.py složitější nerovnost s goniometrickou funkcí https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy35.py
36 sympy36.py řešení dvojice nerovnic https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy36.py
37 sympy37.py složitější dvojice nerovnic https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy37.py
       
38 sympy38.py první derivace funkce https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy38.py
39 sympy39.py první derivace odlišné funkce https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy39.py
40 sympy40.py první až čtvrtá derivace funkce https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy40.py
41 sympy41.py první až čtvrtá derivace odlišné funkce https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy41.py
42 sympy42.py první až čtvrtá derivace odlišné funkce https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy42.py
43 sympy43.py první až čtvrtá derivace odlišné funkce https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy43.py
44 sympy44.py výpočet singularit, jichž je konečné množství https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy44.py
45 sympy45.py výpočet singularit, jichž je nekonečné (spočetné) množství https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy45.py
46 sympy46.py výpočet singularit v oboru komplexních čísel https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy46.py
47 sympy47.py výpočet singularit v oboru komplexních čísel https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy47.py
48 sympy48.py výpočet lokálního minima https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy48.py
49 sympy49.py výpočet lokálního maxima https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy49.py
50 sympy50.py test, zda je funkce v zadaném intervalu rostoucí https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy50.py
51 sympy51.py test, zda je funkce v zadaném intervalu klesající https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy51.py
52 sympy52.py otevřené intervaly a test na rostoucí funkci https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy52.py
53 sympy53.py výpočet limity (zprava) funkce y=1/x v nule https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy53.py
54 sympy54.py výpočet limity (zleva) funkce y=1/x v nule https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy54.py
55 sympy55.py výpočet limity funkce y=1/x v nekonečnu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy55.py
56 sympy56.py výpočet limity funkce y=1/x v záporném nekonečnu https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy56.py
57 sympy57.py výpočet limity funkce y=sin(1/x) v nule https://github.com/tisnik/most-popular-python-libs/blob/master/sympy/sympy57.py

20. Odkazy na Internetu

  1. SymPy
    https://www.sympy.org/en/index.html
  2. SymPy na PyPi
    https://pypi.org/project/sympy/
  3. mpmath
    https://mpmath.org/
  4. mpmath na PyPi
    https://pypi.org/project/mpmath/
  5. Symbolic Maths in Python
    https://alexandrugris.git­hub.io/maths/2017/04/30/sym­bolic-maths-python.html
  6. SymPy shell
    https://live.sympy.org/
  7. Symbolic programming
    https://en.wikipedia.org/wi­ki/Symbolic_programming
  8. Symbolic language (programming)
    https://en.wikipedia.org/wi­ki/Symbolic_language_(pro­gramming)
  9. Computer algebra
    https://en.wikipedia.org/wi­ki/Computer_algebra
  10. Common Lisp: A Gentle Introduction to Symbolic Computation
    https://www.cs.cmu.edu/~dst/LispBook/
  11. List of computer algebra systems
    https://en.wikipedia.org/wi­ki/List_of_computer_algebra_sys­tems
  12. Polynom
    https://cs.wikipedia.org/wiki/Polynom
  13. What is SimPy? How to run python simulations?
    https://divyas090909.medium.com/what-is-simpy-how-to-run-python-simulations-348736b50615
  14. SimPy: Simulating Real-World Processes With Python
    https://realpython.com/simpy-simulating-with-python/