SciPy: první seznámení s knihovnou pro vědecké a technické výpočty

12. 3. 2026

Doba čtení: 26 minut

Líbí se vám článek?
Podpořte redakci

Vědec používá ke své práci počítač a Python

V dnešním článku se ve stručnosti seznámíme s knihovnou SciPy, která nabízí funkce a třídy s realizací různých vědeckých a/nebo technických výpočtů (zpracování signálů atd.). Velkou předností je i kompatibilita s NumPy.

Obsah

1. Knihovna SciPy – první seznámení

2. Vztah mezi knihovnami NumPy a SciPy

3. Příprava projektového souboru pro spouštění demonstračních příkladů

4. Modul lineární algebry scipy.linalg

5. Výpočet determinantu v oboru reálných i komplexních čísel

6. Determinant singulárních matic

7. Výpočet inverzní matice

8. Výpočet inverzní matice k matici singulární

9. Ověření korektnosti výpočtů inverzní matice

10. Řešení soustavy lineárních rovnic

11. Vyřešení triviálního případu: jedna rovnice o jedné neznámé

12. Vyřešení systému dvou lineárních rovnic o dvou neznámých

13. Vyřešení systému tří lineárních rovnic o třech neznámých

14. Situace, která nastane, pokud je nějaká rovnice lineární kombinací jiných rovnic

15. Výpočet normy vektoru

16. Eukleidovská norma

17. Další normy pro vektory

18. Normy pro matice

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

20. Odkazy na Internetu

1. Knihovna SciPy – první seznámení

V ekosystému programovacího jazyka Python vzniklo relativně velké množství knihoven určených pro provádění vědeckých a/nebo technických výpočtů. Prozatím jsme se seznámili s knihovnami NumPy (numerické výpočty v vektory a maticemi, lineární algebra atd.), SymPy (symbolické výpočty), Xarray (zpracování datových sad s vektory a maticemi) a Matplotlib (vizualizace vstupů a/nebo výsledků). Ovšem zapomenout nesmíme ani na knihovnu nazvanou SciPy. Tato knihovna svým uživatelům nabízí funkce a třídy určené pro provádění vědeckých a technických výpočtů. Vzhledem k rozsáhlosti celé problematiky je SciPy rozdělena do několika (sub)modulů, s jejichž základními vlastnostmi se postupně seznámíme. Mezi realizované submoduly patří například modul pro lineární algebru, zpracování signálů, zpracování n-dimenzionálních obrázků, Fourierovu transformaci (patří do oblasti zpracování signálů), numerickou integraci, interpolaci, řešení diferenciálních rovnic atd.

2. Vztah mezi knihovnami NumPy a SciPy

Na stránkách Roota jsme se již několikrát setkali s knihovnou NumPy. V této oblíbené a často používané knihovně se pracuje s vektory a maticemi, podobně jako v knihovně SciPy (resp. v některých jejich submodulech). Dokonce obě knihovny nabízí podobně nazvaný submodul scipy.linalg resp. numpy.linalg. Nabízí se tedy otázka, jaký je vztah mezi těmito knihovnami a zda se jejich možnosti překrývají. Do jisté míry tomu tak je, ale vhodnější je chápat knihovnu NumPy jako základ, nad kterým je postavena ucelenější knihovna SciPy. Možnosti obou knihoven se tak spíše doplňují (a striktně řečeno by mohla být NumPy například dodávána zcela bez výše uvedeného modulu numpy.linalg; bylo by to čistší řešení).

Při práci s oběma knihovnami se setkáme s termínem n-rozměrné pole neboli ndarray, takže se s ním ve stručnosti seznámíme.

Funkce a objekty nabízené knihovnou NumPy se sice volají přímo z Pythonu, ve skutečnosti se však interní datové struktury dosti podstatným způsobem odlišují od datových struktur využívaných samotným Pythonem. V knihovně NumPy tvoří základ datová struktura nazvaná ndarray, která reprezentuje pole o prakticky libovolném počtu dimenzí (ostatně „nd“ ve jménu „ndarray“ značí N-dimensional). Tato pole se liší od běžných seznamů či n-tic v Pythonu, protože ndarray jsou homogenní datovou strukturou: všechny prvky totiž mají shodný typ a navíc všechny prvky leží za sebou, zatímco seznamy v Pythonu jsou měnitelné (prvky lze přidávat a odebírat) a obecně nehomogenní (každý prvek může mít odlišný datový typ). Za tuto velkou flexibilitu se samozřejmě platí, a to jak většími nároky na operační paměť (reference na objekty), tak i pomalejším zpracováním.

A právě ndarray je akceptováno funkcemi SciPy, jak si to ostatně ukážeme v praktické části dnešního článku.

3. Příprava projektového souboru pro spouštění demonstračních příkladů

Tento článek je zaměřen především na praktické ukázky použití knihovny SciPy. Musíme si tedy připravit projekt v Pythonu a následně do něj knihovnu SciPy přidat formou přímé závislosti (dependency). Pro vytvoření projektu použijeme buď nástroj PDM – viz též PDM: moderní správce balíčků a virtuálních prostředí Pythonu nebo (což je v současnosti výhodnější) nástroj uv:

$ uv init
 
Initialized project `scipy-lib`

Projekt bude vytvořen v novém (původně prázdném) adresáři a jeho projektový soubor pyproject.toml může vypadat následovně (lišit se bude verze Pythonu atd., to jsou však malé rozdíly):

[project]
name = "scipy-lib"
version = "0.1.0"
description = "Scipy examples"
readme = "README.md"
requires-python = "==3.11.*"
dependencies = []

Příkazem pdm add nebo uv add do projektu přidáme knihovnu SciPy:

$ uv add scipy

Automaticky se přidají i tranzitivní závislosti, ale v tomto případě by se mělo jednat jen o knihovnu NumPy:

Using CPython 3.13.9 interpreter at: /usr/bin/python3.13
Creating virtual environment at: .venv
Resolved 3 packages in 173ms
Installed 2 packages in 566ms
 + numpy==2.4.2
 + scipy==1.17.1

Výsledný projektový soubor by měl vypadat takto:

[project]
name = "scipy-lib"
version = "0.1.0"
description = "Scipy examples"
readme = "README.md"
requires-python = "==3.11.*"
dependencies = [
    "scipy>=1.17.1",
]

Strom závislostí si pochopitelně můžeme zobrazit:

$ uv tree
 
Resolved 3 packages in 1ms
scipy-lib v0.1.0
└── scipy v1.17.1
    └── numpy v2.4.2

Nyní si již můžeme otestovat, zda je knihovna SciPy dostupná. Spustíme interpret Pythonu, ovšem v rámci virtuálního prostředí projektu:

$ uv run python
 
Python 3.12.10 (main, Apr 22 2025, 00:00:00) [GCC 14.2.1 20240912 (Red Hat 14.2.1-3)] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

Provedeme import knihovny SciPy a necháme si zobrazit její nápovědu:

>>> import scipy
 
>>> help(scipy)

Výsledek by měl vypadat následovně:

Help on package scipy:
 
NAME
    scipy
 
DESCRIPTION
    SciPy: A scientific computing package for Python
    ================================================
 
    Documentation is available in the docstrings and
    online at https://docs.scipy.org/doc/scipy/
 
    Subpackages
    -----------
    ::
 
     cluster                      --- Vector Quantization / Kmeans
     constants                    --- Physical and mathematical constants and units
     datasets                     --- Dataset methods
     differentiate                --- Finite difference differentiation tools
     fft                          --- Discrete Fourier transforms
     fftpack                      --- Legacy discrete Fourier transforms
     integrate                    --- Integration routines
     interpolate                  --- Interpolation Tools
     io                           --- Data input and output
     linalg                       --- Linear algebra routines
     ndimage                      --- N-D image package
     odr                          --- Orthogonal Distance Regression
     optimize                     --- Optimization Tools
     signal                       --- Signal Processing Tools
     sparse                       --- Sparse Matrices
     spatial                      --- Spatial data structures and algorithms
     special                      --- Special functions
     stats                        --- Statistical Functions

4. Modul lineární algebry scipy.linalg

V balíčku SciPy nalezneme poměrně velké množství modulů, jejichž možnosti si postupně popíšeme. Základem je modul nazvaný linalg, resp. plným jménem scipy.linalg. V tomto modulu jsou definovány funkce a třídy s výpočty z oblasti lineární algebry (což je oblíbený předmět v prvních ročnících vysokých škol). V tomto modulu se pracuje s vektory a maticemi typu ndarray (viz knihovnu NumPy). Nalezneme zde realizaci základních operací s maticemi a vektory (výpočet determinantu, výpočet inverzní matice), ale například i funkce určené pro řešení sady lineárních rovnic nebo pro výpočet normy vektoru nebo matice:

Help on package scipy.linalg in scipy:
 
NAME
    scipy.linalg
 
DESCRIPTION
    ====================================
    Linear algebra (:mod:`scipy.linalg`)
    ====================================
 
    .. currentmodule:: scipy.linalg
 
    .. toctree::
       :hidden:
 
       linalg.blas
       linalg.cython_blas
       linalg.cython_lapack
       linalg.interpolative
       linalg.lapack
 
    Linear algebra functions.
 
    .. eventually, we should replace the numpy.linalg HTML link with just `numpy.linalg`
 
    .. seealso::
 
       `numpy.linalg <https://www.numpy.org/devdocs/reference/routines.linalg.html>`__
       for more linear algebra functions. Note that identically named
       functions from `scipy.linalg` may offer more or slightly differing
       functionality.

Poznámka: v nápovědě si povšimněte názvů BLAS a LAPACK. BLAS znamená Basic Linear Algebra Subprograms a LAPACK je zkratka vzniklá z Linear Algebra Package (což je sada podprogramů vytvořených ve Fortranu). K těmto názvům se později vrátíme.

5. Výpočet determinantu v oboru reálných i komplexních čísel

Jednou z nejzákladnějších funkcí, kterou v balíčku scipy.linalg můžeme nalézt, je funkce linalg.det, která je určena pro výpočet determinantu:

from scipy import linalg
 
help(linalg.det)

Za povšimnutí stojí, že výpočet může být proveden s maticemi, které obsahují buď reálná čísla, nebo dokonce i čísla komplexní:

Help on function det in module scipy.linalg._basic:
 
det(a, overwrite_a=False, check_finite=True)
    Compute the determinant of a matrix
 
    The determinant is a scalar that is a function of the associated square
    matrix coefficients. The determinant value is zero for singular matrices.
 
    Array argument(s) of this function may have additional
    "batch" dimensions prepended to the core shape. In this case, the array is treated
    as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details.
 
    Parameters
    ----------
    a : (..., M, M) array_like
        Input array to compute determinants for.
    overwrite_a : bool, optional
        Allow overwriting data in a (may enhance performance).
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.
 
    Returns
    -------
    det : (...) float or complex
        Determinant of `a`. For stacked arrays, a scalar is returned for each
        (m, m) slice in the last two dimensions of the input. For example, an
        input of shape (p, q, m, m) will produce a result of shape (p, q). If
        all dimensions are 1 a scalar is returned regardless of ndim.

Výpočet determinantu regulární čtvercové matice o rozměrech 3×3 prvky může vypadat následovně:

import numpy as np
from scipy import linalg
 
m = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 1]])
print(m)
print()
 
det = linalg.det(m)
print("Determinant:" )
print(det)

Výsledek získaný po spuštění tohoto demonstračního příkladu:

[[0 1 0]
 [1 1 1]
 [0 1 1]]
 
Determinant:
-1.0

Tentýž výpočet, ale tentokrát provedený v oboru komplexních čísel, bude vypadat následovně:

import numpy as np
from scipy import linalg
 
m = np.array([[0+0j, 1+0j, 0+1j], [1+0j, 1+1j, 1-1j], [0+0j, 1+0j, 1+2j]])
print(m)
print()
 
det = linalg.det(m)
print("Determinant:" )
print(det)

Výsledek:

[[0.+0.j 1.+0.j 0.+1.j]
 [1.+0.j 1.+1.j 1.-1.j]
 [0.+0.j 1.+0.j 1.+2.j]]
 
Determinant:
(-1-1j)

6. Determinant singulárních matic

Zajímavé bude zjistit, jestli je možné výpočet determinantu využít pro detekci singulárních matic. S těmito maticemi se setkáme i v navazujících kapitolách, protože budou komplikovat například výpočty inverzních matic atd. Nejprve si ověříme, že determinant nulové matice je taktéž nulový (a nulová matice je triviálním příkladem matice singulární):

import numpy as np
from scipy import linalg
 
m = np.zeros((5, 5))
print(m)
print()
 
det = linalg.det(m)
print("Determinant:" )
print(det)

Výsledek:

[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]
 
Determinant:
0.0

Ovšem singulární matice nemusí mít nulové prvky. I matice, která má lineárně závislé sloupce nebo řádky je maticí singulární a její determinant by měl být nulový. To si pochopitelně taktéž ověříme, a to konkrétně na matici 2×2 prvky, která má lineárně závislé řádky:

import numpy as np
from scipy import linalg
 
m = np.array([[1, -3], [2, -6]])
print(m)
print()
 
det = linalg.det(m)
print("Determinant:" )
print(det)

Výsledek:

[[ 1 -3]
 [ 2 -6]]
 
Determinant:
0.0

Totéž platí i pro matice obsahující komplexní prvky:

import numpy as np
from scipy import linalg
 
m = np.array([[0+1j, 0-3j], [0+2j, 0-6j]])
print(m)
print()
 
det = linalg.det(m)
print("Determinant:" )
print(det)

Výsledek:

[[0.+1.j 0.-3.j]
 [0.+2.j 0.-6.j]]
 
Determinant:
0j

7. Výpočet inverzní matice

Další užitečnou funkcí, kterou v tomto submodulu nalezneme, je funkce pro výpočet inverzní matice. Tato funkce se jmenuje numpy.linalg.inv a její použití je snadné:

from scipy import linalg
 
help(linalg.inv)

Help on function inv in module scipy.linalg._basic:
 
inv(a, overwrite_a=False, check_finite=True, *, assume_a=None, lower=False)
    Compute the inverse of a matrix.
 
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
 
    =============================  ================================
     general                        'general' (or 'gen')
     diagonal                       'diagonal'
     upper triangular               'upper triangular'
     lower triangular               'lower triangular'
     symmetric positive definite    'pos'
     symmetric                      'sym'
     Hermitian                      'her'
    =============================  ================================
 
    For the 'pos' option, only the triangle of the input matrix specified in
    the `lower` argument is used, and the other triangle is not referenced.
    Likewise, an explicit `assume_a='diagonal'` means that off-diagonal elements
    are not referenced.
 
    Array argument(s) of this function may have additional
    "batch" dimensions prepended to the core shape. In this case, the array is treated
    as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details.

Pokusme se o výpočet inverzní matice k matici regulární (tj. nikoli singulární):

import numpy as np
from scipy import linalg
 
m = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 1]])
print(m)
print()
 
inv = linalg.inv(m)
print("Inverse matrix:" )
print(inv)

Výsledek:

[[0 1 0]
 [1 1 1]
 [0 1 1]]
 
Inverse matrix:
[[-0.  1. -1.]
 [ 1. -0.  0.]
 [-1.  0.  1.]]

Výpočet lze provést i pro komplexní prvky matic:

import numpy as np
from scipy import linalg
 
m = np.array([[0+0j, 1+0j, 0+1j], [1+0j, 1+1j, 1-1j], [0+0j, 1+0j, 1+2j]])
print(m)
print()
 
inv = linalg.inv(m)
print("Inverse matrix:" )
print(inv)

Výsledkem bude nová matice s prvky typu komplexní číslo:

[[0.+0.j 1.+0.j 0.+1.j]
 [1.+0.j 1.+1.j 1.-1.j]
 [0.+0.j 1.+0.j 1.+2.j]]
 
Inverse matrix:
[[-1. -3.j   1. -0.j   0. +2.j ]
 [ 1.5+0.5j  0. +0.j  -0.5-0.5j]
 [-0.5+0.5j  0. +0.j   0.5-0.5j]]

8. Výpočet inverzní matice k matici singulární

Pokusme se nyní vypočítat inverzní matici k matici singulární. Začneme nulovou maticí:

import numpy as np
from scipy import linalg
 
m = np.zeros((5, 5))
print(m)
print()
 
inv = linalg.inv(m)
print("Inverse matrix:" )
print(inv)

V tomto případě dojde k běhové výjimce, což je rozumná reakce na neplatný vstup:

[[0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]
 [0. 0. 0. 0. 0.]]
 
Traceback (most recent call last):
  File "/home/ptisnovs/src/most-popular-python-libs/scipy-lib/inverse_2.py", line 8, in <module>
    inv = linalg.inv(m)
          ^^^^^^^^^^^^^
  File "/home/ptisnovs/src/most-popular-python-libs/.venv/lib64/python3.11/site-packages/scipy/linalg/_basic.py", line 1473, in inv
    _format_emit_errors_warnings(err_lst)
  File "/home/ptisnovs/src/most-popular-python-libs/.venv/lib64/python3.11/site-packages/scipy/linalg/_basic.py", line 84, in _format_emit_errors_warnings
    raise LinAlgError(
numpy.linalg.LinAlgError: A singular matrix detected: slice(s) [0] are singular.

Totéž platí i pro nenulové matice, které však mají lineárně závislé řádky nebo sloupce:

import numpy as np
from scipy import linalg
 
m = np.array([[1, -3], [2, -6]])
print(m)
print()
 
inv = linalg.inv(m)
print("Inverse matrix:" )
print(inv)

Výjimka, která je vyhozena, je shodná s výjimkou u předchozího příkladu:

[[ 1 -3]
 [ 2 -6]]
 
Traceback (most recent call last):
  File "/home/ptisnovs/src/most-popular-python-libs/scipy-lib/inverse_3.py", line 8, in <module>
    inv = linalg.inv(m)
          ^^^^^^^^^^^^^
  File "/home/ptisnovs/src/most-popular-python-libs/.venv/lib64/python3.11/site-packages/scipy/linalg/_basic.py", line 1473, in inv
    _format_emit_errors_warnings(err_lst)
  File "/home/ptisnovs/src/most-popular-python-libs/.venv/lib64/python3.11/site-packages/scipy/linalg/_basic.py", line 84, in _format_emit_errors_warnings
    raise LinAlgError(
numpy.linalg.LinAlgError: A singular matrix detected: slice(s) [0] are singular.

9. Ověření korektnosti výpočtů inverzní matice

Jak si ovšem můžeme ověřit, že je inverzní matice vypočtena korektně? Použijeme operaci maticového součinu, která se v NumPy (a tím pádem i ve SciPy) zapisuje pomocí operátoru @ (což je jediný operátor Pythonu, který je sice rezervován, ale nemá přiřazen žádný význam):

import numpy as np
 
m1 = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 1]])
m2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
 
print("Matrix M1")
print(m1)
print()
 
print("Matrix M2")
print(m2)
print()
 
print("M1xM2")
print(m1 @ m2)

Tento příklad provede maticový součin a vypíše výsledek této operace:

Matrix M1
[[0 1 0]
 [1 1 1]
 [0 1 1]]
 
Matrix M2
[[1 2 3]
 [4 5 6]
 [7 8 9]]
 
M1xM2
[[ 4  5  6]
 [12 15 18]
 [11 13 15]]

Ověření vypočtené inverzní matice je tedy snadné:

import numpy as np
from scipy import linalg
 
m1 = np.array([[0, 1, 0], [1, 1, 1], [0, 1, 1]])
 
print("Matrix M")
print(m1)
print()
 
m2 = linalg.inv(m1)
 
print("Inverse matrix")
print(m2)
print()
 
print("M1xM2")
print(m1 @ m2)

Výsledkem součinu je jednotková matice, čímž došlo k ověření:

Matrix M
[[0 1 0]
 [1 1 1]
 [0 1 1]]
 
Inverse matrix
[[-0.  1. -1.]
 [ 1. -0.  0.]
 [-1.  0.  1.]]
 
M1xM2
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]

Ovšem stejně můžeme ověřit výpočet v oblasti komplexních čísel:

import numpy as np
from scipy import linalg
 
m1 = np.array([[0+0j, 1+0j, 0+1j], [1+0j, 1+1j, 1-1j], [0+0j, 1+0j, 1+2j]])
 
print("Matrix M")
print(m1)
print()
 
m2 = linalg.inv(m1)
 
print("Inverse matrix")
print(m2)
print()
 
print("M1xM2")
print(m1 @ m2)

Výsledek:

Matrix M
[[0.+0.j 1.+0.j 0.+1.j]
 [1.+0.j 1.+1.j 1.-1.j]
 [0.+0.j 1.+0.j 1.+2.j]]
 
Inverse matrix
[[-1. -3.j   1. -0.j   0. +2.j ]
 [ 1.5+0.5j  0. +0.j  -0.5-0.5j]
 [-0.5+0.5j  0. +0.j   0.5-0.5j]]
 
M1xM2
[[1.+0.j 0.+0.j 0.+0.j]
 [0.+0.j 1.+0.j 0.+0.j]
 [0.+0.j 0.+0.j 1.+0.j]]

Poznámka: nenechte se zmást, i zde se jedná o jednotkovou matici.

10. Řešení soustavy lineárních rovnic

Další užitečnou funkcí (a to nejenom pro studenty :-) je funkce nazvaná scipy.linalg.solve. Tato funkce slouží pro vyřešení systému lineárních rovnic, ovšem za předpokladu, že tato soustava má řešení (rovnice nejsou lineárně závislé atd.). Funkce solve akceptuje minimálně dva parametry – matici s koeficienty původních rovnic a vektor obsahující pravé strany původních rovnic:

from scipy import linalg
 
help(linalg.solve)

Z nápovědy je patrné, že existuje hned několik variant této funkce:

Help on function solve in module scipy.linalg._basic:
 
solve(a, b, lower=False, overwrite_a=False, overwrite_b=False, check_finite=True, assume_a=None, transposed=False)
    Solve the equation ``a @ x = b`` for  ``x``,
    where `a` is a square matrix.
 
    If the data matrix is known to be a particular type then supplying the
    corresponding string to ``assume_a`` key chooses the dedicated solver.
    The available options are
 
    =============================  ================================
     diagonal                       'diagonal'
     tridiagonal                    'tridiagonal'
     banded                         'banded'
     upper triangular               'upper triangular'
     lower triangular               'lower triangular'
     symmetric                      'symmetric' (or 'sym')
     hermitian                      'hermitian' (or 'her')
     symmetric positive definite    'positive definite' (or 'pos')
     general                        'general' (or 'gen')
    =============================  ================================
 
    Array argument(s) of this function may have additional
    "batch" dimensions prepended to the core shape. In this case, the array is treated
    as a batch of lower-dimensional slices; see :ref:`linalg_batch` for details.
 
    Parameters
    ----------
    a : array_like, shape (..., N, N)
        Square left-hand side matrix or a batch of matrices.
    b : (..., N, NRHS) array_like
        Input data for the right hand side or a batch of right-hand sides.
    lower : bool, default: False
        Ignored unless ``assume_a`` is one of ``'sym'``, ``'her'``, or ``'pos'``.

11. Vyřešení triviálního případu: jedna rovnice o jedné neznámé

Nejprve se podívejme na triviální příklad jediné rovnice:

2x = 10

Důkaz, že je řešení x=5 správné, asi není zapotřebí provádět…

Tuto soustavu (jedné) rovnice je pochopitelně možné vyřešit z hlavy, ovšem my si ukážeme, jak se vlastně rovnice převede na parametry kompatibilní s funkcí solve. Musíme vytvořit matici s koeficienty na levé straně rovnice a vektor pravých stran (resp. zde jediné pravé strany). Matice s koeficienty obsahuje jediný prvek – dvojku. Vektor pravých stran obsahuje taktéž jediný prvek – 10. Řešení tedy získáme takto:

# Vyřešení systému lineárních rovnic
# - Triviální příklad - jedna rovnice o jedné neznámé
# - Rovnice 2x = 10
# - Maticově
#      - levá strana rovnice
#      - pravá strana rovnice
# 
 
import numpy as np
from scipy import linalg
 
# levá strana rovnice (koeficienty)
a = np.array([[2]])
 
# pravá strana rovnice
b = np.array([10])
 
# řešení
c = linalg.solve(a, b)
 
# tisk výsledku operace
print(c)

Výsledek, který se vypíše po spuštění tohoto příkladu:

[5.]

Jak se tento výsledek interpretuje? Jedná se o hodnotu, kterou je nutné dosadit do jediné neznámé v rovnici, tj. v našem konkrétním případě do proměnné x. Tedy vypočítané řešení je:

x = 5

12. Vyřešení systému dvou lineárních rovnic o dvou neznámých

V případě soustavy dvou rovnic:

x + y = 2
x - y = 0

budeme postupovat následovně: matice koeficientů z levých stran rovnic obsahuje koeficienty před x a y, což jsou v tomto případě jedničky a záporné jedničky. A vektor pravých stran obsahuje dvojici hodnot [2, 0]:

# Vyřešení systému lineárních rovnic
#  - Dvě rovnice o dvou neznámých
#       - x + y = 2
#       - x - y = 0
#  - Maticově
#      - levé strany rovnic
#      - pravé strany rovnic
# 
 
import numpy as np
from scipy import linalg
 
# levá strana rovnice (koeficienty)
# matice koeficientů původních rovnic
# [1,1] znamená 1*x + 1*y
a = np.array([[1, 1], [1, -1]])
 
# matice pravých stran rovnic
b = np.array([2, 0])
 
# řešení
c = linalg.solve(a, b)
 
# tisk výsledku operace
print(c)

Řešení v tomto případě existuje, protože rovnice jsou na sobě lineárně nezávislé a program ho nalezne a vypíše:

[1. 1.]

To tedy znamená, že řešení vypadá:

x = 1
y = 1

13. Vyřešení systému tří lineárních rovnic o třech neznámých

Zadání dalšího příkladu jsem získal ze školního příkladu (odkaz na něj ovšem již neexistuje):

2×₁ + 3×₂ + 7×₃ = 47
3×₁ + 8×₂ + x₃ = 50
3×₂ + 3×₃ = 27

Proveďme výpočet této soustavy tří rovnic o třech neznámých:

# Vyřešení systému lineárních rovnic
#  - Tři rovnice o třech neznámých
#
#     2x₁ + 3x₂ + 7x₃ = 47
#     3x₁ + 8x₂ +  x₃ = 50
#           3x₂ + 3x₃ = 27
# 
 
import numpy as np
from scipy import linalg
 
# levá strana rovnice (koeficienty)
# matice koeficientů původních rovnic
a = np.array([[2, 3, 7], [3, 8, 1], [0, 3, 3]])
 
# matice pravých stran rovnic
b = np.array([47, 50, 27])
 
# řešení
c = linalg.solve(a, b)
 
# tisk výsledku operace
print(c)

Výsledný vektor:

[2. 5. 4.]

Vypočtený výsledek tedy zní:

x₁ = 2
x₂ = 5
x₃ = 4

Výsledek lze ověřit součinem matice na levé straně a vektoru s vypočtenými výsledky. Vypočtený vektor by měl být totožný s vektorem pravých stran.

Varianta s komplexními koeficienty:

import numpy as np
from scipy import linalg
 
# levá strana rovnice (koeficienty)
# matice koeficientů původních rovnic
a = np.array([[0+2j, 0+3j, 0+7j], [0+3j, 0+8j, 0+1j], [0+0j, 0+3j, 0+3j]])
 
# matice pravých stran rovnic
b = np.array([47, 50, 27])
 
# řešení
c = linalg.solve(a, b)
 
# tisk výsledku operace
print(c)

Výsledek:

[0.-2.j 0.-5.j 0.-4.j]

Řešení je tedy rovno:

x₁ = -2i
x₂ = -5i
x₃ = -4i

14. Situace, která nastane, pokud je nějaká rovnice lineární kombinací jiných rovnic

Pokud je nějaká rovnice (či více rovnic) lineární kombinací ostatních rovnic, nemusí řešení soustavy rovnic existovat. I toto tvrzení si můžeme snadno ověřit na příkladu dvou rovnic o dvou neznámých:

# Pokus o vyřešení systému lineárních rovnic
#  - Dvě rovnice o dvou neznámých
#       -  x +  y = 2
#       - 2x + 2y = 4
#  - Rovnice 2 je lineární kombinací rovnice 1
#  - Maticově
#      - levé strany rovnic
#      - pravé strany rovnic
# 
 
import numpy as np
from scipy import linalg
 
# levá strana rovnice (koeficienty)
# matice koeficientů původních rovnic
# [1,1] znamená 1*x + 1*y
a = np.array([[1, 1], [2, 2]])
 
# matice pravých stran rovnic
b = np.array([2, 4])
 
# řešení
c = linalg.solve(a, b)
 
# tisk výsledku operace
print(c)

Výsledek:

Traceback (most recent call last):
  File "/home/ptisnovs/src/most-popular-python-libs/scipy-lib/solve_4.py", line 23, in <module>
    c = linalg.solve(a, b)
        ^^^^^^^^^^^^^^^^^^
  File "/home/ptisnovs/src/most-popular-python-libs/.venv/lib64/python3.11/site-packages/scipy/linalg/_basic.py", line 300, in solve
    _format_emit_errors_warnings(err_lst)
  File "/home/ptisnovs/src/most-popular-python-libs/.venv/lib64/python3.11/site-packages/scipy/linalg/_basic.py", line 84, in _format_emit_errors_warnings
    raise LinAlgError(
numpy.linalg.LinAlgError: A singular matrix detected: slice(s) [0] are singular.

Opět je tedy vyhozena výjimka typu LinAlgError.

15. Výpočet normy vektoru

Poslední funkcí knihovny SciPy, s níž se dnes seznámíme, je funkce pro výpočet normy vektoru (nebo, jak uvidíme později, tak i matice). Norma je funkce, která každému nenulovému vektoru z nějakého vektorového prostoru přiřazuje reálné číslo. To se označuje jako délka nebo velikost. Nulový vektor jako jediný má délku rovnou nule. Existuje více realizací normy, tj. lze použít různé funkce, z nichž některé jsou v knihovně SciPy realizovány:

norm(a, ord=None, axis=None, keepdims=False, check_finite=True)
    Matrix or vector norm.
 
    This function is able to return one of eight different matrix norms,
    or one of an infinite number of vector norms (described below), depending
    on the value of the ``ord`` parameter. For tensors with rank different from
    1 or 2, only `ord=None` is supported.
 
    Parameters
    ----------
    a : array_like
        Input array. If `axis` is None, `a` must be 1-D or 2-D, unless `ord`
        is None. If both `axis` and `ord` are None, the 2-norm of
        ``a.ravel`` will be returned.
    ord : {int, inf, -inf, 'fro', 'nuc', None}, optional
        Order of the norm (see table under ``Notes``). inf means NumPy's
        `inf` object.
    axis : {int, 2-tuple of ints, None}, optional
        If `axis` is an integer, it specifies the axis of `a` along which to
        compute the vector norms. If `axis` is a 2-tuple, it specifies the
        axes that hold 2-D matrices, and the matrix norms of these matrices
        are computed. If `axis` is None then either a vector norm (when `a`
        is 1-D) or a matrix norm (when `a` is 2-D) is returned.
    keepdims : bool, optional
        If this is set to True, the axes which are normed over are left in the
        result as dimensions with size one. With this option the result will
        broadcast correctly against the original `a`.
    check_finite : bool, optional
        Whether to check that the input matrix contains only finite numbers.
        Disabling may give a performance gain, but may result in problems
        (crashes, non-termination) if the inputs do contain infinities or NaNs.

16. Eukleidovská norma

Pravděpodobně nejznámější normou je Eukleidovská norma. Jedná se o běžnou Eukleidovskou vzdálenost (povšimněte si, že se skutečně jedná o normu, která platí dokonce i pro nulové vektory). Otestujme se výpočet této normy na vektoru [1, 1], jehož Eukleidovská vzdálenost by měla být rovna √2:

import numpy as np
from scipy import linalg
 
v = np.array([1, 1])
print("Vector:", v)
 
n = linalg.norm(v)
print("Norm:", n)

Výsledek je v tomto případě korektní:

Vector: [1 1]
Norm: 1.4142135623730951

17. Další normy pro vektory

Nepovinným parametrem ord předaným do funkce scipy.linalg.norm je možné provést výběr normy použité při výpočtech. Pro vektory lze zadat tyto hodnoty:

ord=	Stručný popis
None	Eukleidovská norma (již známe)
inf	prvek vektoru s maximální absolutní hodnotou
-inf	prvek vektoru s minimální absolutní hodnotou (což není korektní norma)
0	počet všech nenulových prvků (toto je platná norma)
jiné číslo	výsledek výpočtu sum(abs(a)ord)(1./ord)

Poznámka: dvojhvězdičkou se v Pythonu značí operace umocňování.

Otestujme si nyní výpočty první čtyř norem:

import numpy as np
from scipy import linalg
 
v = np.array([0, 1, 2, 3, 0])
print("Vector:", v)
 
n = linalg.norm(v)
print("Default norm: ", n)
 
n = linalg.norm(v, ord=float('inf'))
print("Norm for inf: ", n)
 
n = linalg.norm(v, ord=float('-inf'))
print("Norm for -inf:", n)
 
n = linalg.norm(v, ord=0)
print("Norm for 0:   ", n)

Podívejme se na vypočtené výsledky pro vstupní vektor [0, 1, 2, 3, 0]:

Vector: [0 1 2 3 0]
Default norm:  3.7416573867739413     ; Eukleidovská vzdálenost
Norm for inf:  3.0                    ; prvek s největší absolutní hodnotou
Norm for -inf: 0.0                    ; prvek s nejmenší absolutní hodnotou
Norm for 0:    3.0                    ; počet nenulových prvků vektoru

18. Normy pro matice

Normy lze vypočítat i pro matice. Ukažme si normy vybrané pro parametr ord=1 a ord=-1. První norma provádí výpočet max(sum(abs(a)), druhá výpočet min(sum(abs(a)), a to přes druhou osu matice. Jedná se tedy vlastně o rozšíření podobných typů norem pro vektory, ovšem zde je nutné operací sum sečíst buď řádky nebo sloupce matic a poté vybírat maximální nebo minimální součet:

import numpy as np
from scipy import linalg
 
m1 = np.array([[-3, 5, 7], [2, 6, 4], [0, 2, 8]])
print("Matrix M1")
print(m1)
print()
 
n = linalg.norm(m1, ord=1)
print("Norm (max):", n)
 
n = linalg.norm(m1, ord=-1)
print("Norm (min):", n)

Matrix M1
[[-3  5  7]
 [ 2  6  4]
 [ 0  2  8]]
 
Norm (max): 19.0
Norm (min): 5.0

Zde se sčítají sloupce resp. absolutní hodnoty sloupců, takže vyjde mezivýsledek ve formě vektoru:

[3+2+0=5, 5+6+2=13, 7+4+8=19]

A podle vybrané normy se vrátí 19 nebo 5.

Poznámka: pro matice jsou podporovány i další typy norem, ty si ukážeme a popíšeme příště.

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

Všechny demonstrační příklady popsané v tomto článku naleznete i v repositáři https://github.com/tisnik/most-popular-python-libs. Následují odkazy na jednotlivé příklady:

#	Příklad	Stručný popis	Adresa příkladu
1	pyproject.toml	projektový soubor používaný všemi demonstračními příklady	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/pyproject.toml

2	help.py	zobrazení nápovědy k celé knihovně SciPy	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/help.py
3	help_linalg.py	zobrazení nápovědy k modulu linalg, který je součástí SciPy	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/help_linalg.py

4	determinant₀.py	nápověda k funkci linalg.det	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/determinant₀.py
5	determinant₁.py	výpočet determinantu běžné regulární matice	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/determinant₁.py
6	determinant₂.py	výpočet determinantu nulové matice	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/determinant₂.py
7	determinant₃.py	výpočet determinantu singulární matice	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/determinant₃.py
8	determinant₄.py	výpočet determinantu v oboru komplexních čísel	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/determinant₄.py
9	determinant₅.py	výpočet determinantu singulární matice v oboru komplexních čísel	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/determinant₅.py

10	inverse₀.py	nápověda k funkci linalg.inv	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/inverse₀.py
11	inverse₁.py	výpočet inverzní matice	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/inverse₁.py
12	inverse₂.py	výpočet inverzní matice k nulové matici	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/inverse₂.py
13	inverse₃.py	výpočet inverzní matice k singulární matici	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/inverse₃.py
14	inverse₄.py	výpočet inverzní matice v oboru komplexních čísel	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/inverse₄.py

15	matrix_mul.py	maticový součin založený na operátoru @ definovaného v NumPy	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/matrix_mul.py
16	matrix_mul_inv.py	důkaz, že byla vypočtena korektní inverzní matice	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/matrix_mul_inv.py
17	matrix_mul_inv₂.py	důkaz, že byla vypočtena korektní inverzní matice v oboru komplexních čísel	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/matrix_mul_inv₂.py

18	solve₀.py	zobrazení nápovědy k funkci linalg.solve	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/solve₀.py
19	solve₁.py	vyřešení triviálního případu: jedna rovnice o jedné neznámé	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/solve₁.py
20	solve₂.py	vyřešení systému dvou lineárních rovnic o dvou neznámých	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/solve₂.py
21	solve₃.py	vyřešení systému tří lineárních rovnic o třech neznámých	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/solve₃.py
22	solve₄.py	situace, která nastane, pokud je nějaká rovnice lineární kombinací jiných rovnic	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/solve₄.py
23	solve₅.py	situace, která nastane, pokud je nějaká rovnice lineární kombinací jiných rovnic	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/solve₅.py

20	vector_norm₀.py	zobrazení nápovědy k funkci linalg.norm	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/vector_norm₀.py
21	vector_norm₁.py	výpočet výchozí normy vektoru (Eukleidovská vzdálenost)	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/vector_norm₁.py
22	vector_norm₂.py	výpočet dalších norem vektoru	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/vector_norm₂.py

23	matrix_norm₁.py	výpočet norem matice: maximová a minimová norma	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/matrix_norm₁.py
24	matrix_norm₂.py	výpočet norem matice: největší a nejmenší hodnota pro Eukleidovské vzdálenosti	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/matrix_norm₂.py
25	matrix_norm₃.py	výpočet norem matice: největší a nejmenší hodnota pro Eukleidovské vzdálenosti	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/matrix_norm₃.py
26	matrix_norm₄.py	výpočet norem matice: Frobeniův skalární součin	https://github.com/tisnik/most-popular-python-libs/blob/master/scipy-lib/matrix_norm₄.py