`numpy` — operace s poli kompatibilní s numpy¶

Podmodul numpy modulu ulab poskytuje API kompatibilní s numpy postavené kolem n-rozměrného typu pole ndarray. Implementuje pečlivě vybranou podmnožinu CPython numpy: konstrukci polí, prvkovou matematiku, redukce a statistiku, lineární algebru, FFT, generování náhodných čísel, prokládání polynomy a základní I/O.

Podmodul se konvenčně importuje jako np

from ulab import numpy as np

a = np.array([1, 2, 3, 4], dtype=np.float)
b = np.linspace(0, 1, num=5)
c = np.dot(a.reshape((2, 2)), a.reshape((2, 2)))

Každý argument dtype je jedna z celočíselných konstant dostupných na úrovni modulu: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (výchozí) a (je-li zkompilována podpora komplexních čísel) numpy.complex. Výsledný typ ndarray odkazuje na numpy.ndarray.

Podmoduly¶

třída `ndarray` — n-rozměrné pole¶

ndarray je n-rozměrný kontejner s informací o dtype, který tvoří jádro numpy / ulab. Data jsou uložena ve souvislém bloku, jehož interpretaci popisuje malá hlavička (dtype, shape, strides, ndim, itemsize). Mnoho operací – reshape, transpose, krájení – pouze upravuje tuto hlavičku, a jsou proto velmi levné; metody, které alokují nové úložiště (copy, flatten, většina aritmetiky), vracejí nové husté pole.

Stejný typ je dostupný jako ulab.ndarray, numpy.ndarray a (v rámci této stránky) jednoduše ndarray.

class numpy.ndarray(values: ndarray | bytes | list | tuple, *, dtype: int = numpy.float)¶

Vytvoří nové ndarray.

Parametry:

values – Zdrojová data. Buď jiné ndarray (které se hluboce zkopíruje, s konverzí typu, pokud se dtype liší), nebo libovolná MicroPython iterovatelná struktura. Vnořené iterovatelné struktury produkují vícerozměrná pole; všechny vnitřní iterovatelné struktury musí mít stejnou délku, jinak je vyvolán ValueError.
dtype – Typ prvku pro nové pole. Jeden z celočíselných typových kódů dostupných v numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float a – je-li podporováno – numpy.complex), nebo instance dtype. Výchozí je numpy.float.

Tovární funkce numpy.array je konvenčním způsobem vytvoření ndarray; přeposílá data tomuto konstruktoru.

byteswap(*, inplace: bool = False) → ndarray¶

Prohodí pořadí bajtů každého prvku. U polí uint16, int16, float a complex to obrátí pořadí bajtů v rámci každého prvku, což je užitečné při zpracování dat z periferií, jejichž endianita neodpovídá endianitě mikrokontroléru. U jednobajtových dtype (bool, uint8, int8) jde o operaci bez efektu, která vrací pohled nebo kopii.

Pokud je inplace False (výchozí), vrátí se nové ndarray a originál zůstane nedotčen. Pokud je inplace True, bajty self se prohodí na místě a vrátí se pohled na self.

copy() → ndarray¶: Vrátí novou hustou, hlubokou kopii pole. Kopie vlastní svá vlastní data; její úpravy nemají vliv na originál.

flatten(*, order: str = 'C') → ndarray¶

Vrátí novou jednorozměrnou kopii pole.

Parametry:: order – 'C' (výchozí) prochází data v C pořadí (poslední osa se mění nejrychleji); 'F' je prochází v Fortran pořadí (první osa se mění nejrychleji).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Vrátí pohled na pole s novým tvarem. Celkový počet prvků se nesmí změnit, jinak je vyvolán ValueError. Dostupné pouze při ULAB_MAX_DIMS > 1. Ekvivalentní přiřazení do shape.

sort(*, axis: int | None = -1) → None¶

Seřadí pole na místě.

Parametry:: axis – Osa, podle které se řadí. -1 (výchozí) řadí podle poslední osy; None pole nejprve zploští a poté seřadí.

tobytes() → bytearray¶: Vrátí bytearray, který je aliasem na podkladový datový buffer pole. Zápisy přes vrácené bytearray upravují pole na místě. Vyvolá ValueError, pokud pole není husté (např. krájený pohled).

tolist() → list¶: Vrátí obsah pole jako (případně vnořený) Python list. Hloubka vnoření odpovídá ndim.

transpose() → ndarray¶: Vrátí transpozici pole (s obrácenými osami). U jednorozměrných polí vrací self. Dostupné pouze při ULAB_MAX_DIMS > 1. Atribut T je zkratkou pro tuto metodu.

dtype: dtype | int¶: Datový typ prvků pole. Vrací instanci dtype, pokud je firmware sestaven s povoleným ULAB_HAS_DTYPE_OBJECT, jinak podkladový jednoznakový typový kód jako celé číslo.

flat: flatiter¶: Plochý iterátor, který poskytuje každý prvek pole v C pořadí. Na rozdíl od flatten() iterování flat nealokuje nové pole.

itemsize: int¶: Velikost jednoho prvku pole v bajtech, odvozená z dtype.

ndim: int¶: Počet dimenzí pole (délka shape).

shape: tuple[int, ...]¶: Délky pole podél každé osy. Přiřazení n-tice do shape přetvaruje pole na místě (ekvivalentní reshape()).

size: int¶: Celkový počet prvků v poli (součin shape).

strides: tuple[int, ...]¶: Počet bajtů, o které je třeba se posunout v paměti podél každé osy, aby se dosáhlo dalšího prvku podél této osy.

T: ndarray¶: Transpozice pole; ekvivalentní transpose().

real: ndarray¶: Reálná část komplexního pole, vrácená jako float ndarray. U reálných polí jde o kopii self se stejným dtype. Dostupné pouze tehdy, byl-li firmware sestaven s podporou komplexních čísel.

imag: ndarray¶: Imaginární část komplexního pole, vrácená jako float ndarray. U reálných polí jde o pole nul se stejným dtype jako self. Dostupné pouze tehdy, byl-li firmware sestaven s podporou komplexních čísel.

Podporované operátory¶

Instance ndarray podporují následující operátory. Binární operátory rozšiřují (broadcast) své operandy podle standardních pravidel broadcastingu numpy a řídí se pravidly numpy pro povyšování typů (např. uint8 + int8 => int16, uint16 + int16 => float); operace zahrnující komplexní operand produkují komplexní výsledek.

Aritmetika (binární): +, -, *, /, //, %, **. Podporovány jsou také reflektované (pravostranné) operandy a varianty na místě +=, -=, *=, /=, %=, **=. Přijímány jsou jak formy ndarray-s-ndarray, tak ndarray-se-skalárem. Celočíselné dělení (//) a operátor modulo (%) nejsou pro pole complex implementovány.

Porovnání: ==, !=, <, <=, >, >=. Každý vrací booleovské ndarray o broadcast tvaru.

Bitové (pouze celočíselná pole): &, |, ^. Aplikace na pole float nebo complex vyvolá TypeError.

Unární: + (vrací kopii), - (negace; u bezznaménkových dtype se hodnoty zalamují modulo \(2^N\)), abs() (prvková absolutní hodnota; u bezznaménkových dtype vrací kopii bez výpočtu), ~ (bitová inverze, pouze celočíselné dtype), len() (vrací délku první osy).

Indexování a krájení: a[i], a[i, j, ...], a[start:stop:step], indexování booleovskou maskou (a[mask]) a indexování celočíselným polem (fancy indexing) jsou podporovány jak při čtení, tak při zápisu.

Iterace: Iterování přes ndarray poskytuje podpole podél první osy (po jednom prvku u 1-D polí). Pro iterování přes každý skalární prvek nezávisle na dimenzionalitě použijte flat.

Operátor maticového násobení @ není implementován; místo něj použijte numpy.dot (np.dot(a, b)).

Operátory posunu (<<, >>) nejsou na úrovni operátoru implementovány. Pro prvkové celočíselné posuny použijte numpy.left_shift a numpy.right_shift.

Konstrukce polí¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Sestaví nové ndarray z vnořené iterovatelné struktury čísel. Ekvivalentní alternativní konstruktor pro numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Vrátí rovnoměrně rozložené hodnoty na polootevřeném intervalu [start, stop). Je-li zadán pouze jeden poziční argument, je považován za stop s start = 0. Je-li dtype vynechán, je odvozen ze vstupů (celočíselný, jsou-li všechny start, stop, step celá čísla a v rozsahu).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Pokud je a již ndarray, jehož dtype odpovídá dtype (nebo je dtype None), vrátí a beze změny; jinak vytvoří nové pole (s požadovanou konverzí dtype, je-li zadána). Iterovatelné struktury se konvertují jako v numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Spojí posloupnost ndarray podél existující osy axis. Všechna vstupní pole musí sdílet stejný dtype, ndim a tvar na každé ose kromě axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Pro 2-D a vrátí 1-D pole obsahující k-tou diagonálu. Pro 1-D a vrátí 2-D čtvercové pole s a umístěným na k-té diagonále. k může být kladné (nad hlavní diagonálou) nebo záporné (pod ní).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Alias pro zeros; vrací pole vyplněné nulami o tvaru shape a typu dtype. (ulab nenechává buffer neinicializovaný.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Vrátí 2-D pole N x M (čtvercové N x N, je-li M None) s jedničkami na k-té diagonále a nulami jinde.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Interpretuje objekt implementující buffer protokol jako 1-D ndarray typu dtype. count je počet položek ke čtení (-1 čte všechny dostupné položky); offset přeskočí tolik bajtů na začátku bufferu.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Vrátí nové pole o tvaru shape a typu dtype, kde je každý prvek nastaven na fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Vrátí num rovnoměrně rozložených vzorků na uzavřeném intervalu [start, stop] (nebo polootevřeném, je-li endpoint False). Je-li retstep True, vrátí n-tici (samples, step). Komplexní start/stop produkují komplexní pole (je-li povolena podpora komplexních čísel).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Vrátí num vzorků rozložených rovnoměrně na logaritmické stupnici: výsledek začíná na base ** start a končí na base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Vrátí n-tici souřadnicových matic z posloupnosti jednorozměrných souřadnicových polí. Při indexing 'xy' (výchozí) jsou první dva vstupy považovány za kartézské souřadnice a jejich výstupní osy se prohodí; při 'ij' se použije maticové indexování. Implementace odpovídá ekvivalentu z NumPy s copy=True a sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Vrátí nové pole o tvaru shape a typu dtype vyplněné jedničkami.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Vrátí nové pole o tvaru shape a typu dtype vyplněné nulami.

Inspekce / výpis¶

numpy.get_printoptions() → dict¶: Vrátí aktuální možnosti výpisu polí jako slovník s klíči threshold a edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Nastaví možnosti výpisu polí. threshold je maximální počet prvků pole vypsaných v plném rozsahu; edgeitems je počet položek zobrazených na každém konci osy, když je pole shrnuto.

numpy.ndinfo(array: ndarray) → None¶: Vypíše diagnostické informace (tvar, strides, dtype, itemsize, …) o poli array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Vrátí počet prvků a podél osy axis; je-li axis None, vrátí celkový počet prvků (součin ndarray.shape).

Porovnání¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Ořeže hodnoty a tak, aby a_min <= result <= a_max. Ekvivalentní maximum(a_min, minimum(a, a_max)); broadcasting se řídí stejnými pravidly jako minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Prvkové x1 == x2; vrací booleovské ndarray (nebo skalár bool, jsou-li oba vstupy skaláry). Poskytnuto pro přenositelnost – operátor == na polích dává stejný výsledek.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Prvkové x1 != x2; booleovský protějšek equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Vrátí booleovské pole (nebo skalár), které je True tam, kde je vstup konečný. Celočíselné vstupy jsou vždy konečné.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Vrátí booleovské pole (nebo skalár), které je True tam, kde je vstup nekonečný. Celočíselné vstupy nejsou nikdy nekonečné.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Prvkové maximum dvou polí / skalárů. Argumenty se broadcastují dohromady; liší-li se dtype, výstup se povýší.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Prvkové minimum dvou polí / skalárů; protějšek maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Vrátí n-tici ndarray, jedno na každou dimenzi a, obsahující indexy nenulových prvků a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Vrátí ndarray, jehož prvky pocházejí z x tam, kde je condition pravdivá, a z y jinak. Tři vstupy se broadcastují dohromady; výstupní dtype je povýšení x a y.

Numerické redukce¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Otestuje, zda všechny prvky podél osy axis vyhodnocují na True. S axis=None (výchozí) se testuje zploštěné pole a vrátí se jediný bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Otestuje, zda libovolný prvek podél osy axis vyhodnocuje na True. S axis=None se testuje zploštěné pole.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Vrátí index maximálního prvku podél osy axis. S axis=None se pole zploští a vrátí se jediné celé číslo.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Vrátí index minimálního prvku podél osy axis. S axis=None se pole zploští a vrátí se jediné celé číslo.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Vrátí bezznaménkové celočíselné indexové ndarray, jehož položky řadí a vzestupně podél osy axis. Výstupní dtype je uint16, takže žádná osa nesmí přesáhnout 65535 prvků. axis=None není podporováno.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Vrátí vektorový součin dvou 1-D polí délky 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Vrátí n-tou diskrétní dopřednou diferenci a podél osy axis. n musí být v rozsahu 0..9 (diferenciační šablona je uložena v int8); délka osy axis se zmenší o n. Klíčová slova numpy prepend a append nejsou implementována.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Vrátí nové pole s obráceným pořadím prvků podél osy axis; s axis=None se pole obrátí podél každé osy.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Vrátí maximální prvek podél osy axis. S axis=None (výchozí) se zploštěné pole zredukuje na skalár. Klíčové slovo numpy out není implementováno.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Vrátí minimální prvek podél osy axis; protějšek max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Vrátí aritmetický průměr podél osy axis. S axis=None (výchozí) se vrátí průměr zploštěného pole jako float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Vrátí medián podél osy axis. S axis=None se pole nejprve zploští. Výstupní dtype je vždy float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Vrátí a s prvky cyklicky posunutými o shift pozic. S axis=None (výchozí) se pole nejprve zploští. Záporné posuny rolují opačným směrem.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Vrátí seřazenou kopii a podél osy axis pomocí haldového řazení. S axis=None se pole nejprve zploští. Klíčová slova numpy kind a order nejsou implementována.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Vrátí směrodatnou odchylku podél osy axis. ddof je delta stupňů volnosti – použitý dělitel je N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Vrátí součet podél osy axis. S axis=None se vrátí celkový součet zploštěného pole jako skalár.

Statistika¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Spočítá počet výskytů každé hodnoty v jednorozměrném nezáporném celočíselném poli x. Dtype x musí být uint8 nebo uint16. Je-li zadáno weights, každá položka x přispívá svou odpovídající váhou namísto 1 a výstup je typu float; jinak je výstup typu uint16. Je-li zadáno minlength, výstupní pole má alespoň tolik prvků (přebytečné položky jsou nulové).

numpy.trace(m: ndarray) → int | float¶: Vrátí součet diagonálních prvků čtvercové matice m. Návratový typ se řídí dtype m (celočíselná pole produkují int, pole float produkují float).

Transformace¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Vrátí řezy a vybrané podél osy axis booleovskou podmínkou condition. S axis=None se použije zploštěné pole.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Vrátí kopii a s odstraněnými položkami na indexech indices podél osy axis. S axis=None se pole nejprve zploští. Záporné indexy se počítají od konce osy axis; indices se před odstraněním interně seřadí.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Vrátí skalární součin dvou polí. U dvou 1-D polí jde o vnitřní součin (skalár float). U 2-D polí jde o maticové násobení; vnitřní rozměry se musí shodovat. Výsledek je vždy typu float.

Aproximace¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Jednorozměrná lineární interpolace. xp musí být monotónně rostoucí 1-D pole nezávislých hodnot; fp obsahuje odpovídající závislé hodnoty; x jsou body, ve kterých se interpolant vyhodnocuje. left a right přepisují hodnotu vrácenou pro x < xp[0] resp. x > xp[-1] (výchozí: fp[0] a fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integruje y pomocí složeného lichoběžníkového pravidla. Je-li zadáno x, poskytuje pozice vzorků odpovídající y; jinak se použije rozestup dx. y (a x) musí být 1-D.

Výběr¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Vezme prvky z a na zadaných indexech indices podél osy axis. S axis=None se použije zploštěné pole. mode vybírá chování při překročení mezí: "raise" (výchozí – vyvolá ValueError), "wrap" (modulo délka osy) nebo "clip" (ořez na platný rozsah; záporné indexy nejsou povoleny). Je-li zadáno out, výsledek se do něj zapíše.

Bitové operace¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: Prvkové bitové AND dvou celočíselných polí; broadcasting je podporován. Neceločíselný dtype vyvolá výjimku.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: Prvkové bitové OR dvou celočíselných polí.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: Prvkové bitové XOR dvou celočíselných polí.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Prvkový bitový posun x1 doleva o x2 bitů; obě pole musí mít celočíselný dtype.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Prvkový bitový posun x1 doprava o x2 bitů; obě pole musí mít celočíselný dtype.

Filtrování¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Vrátí diskrétní lineární konvoluci dvou 1-D polí. Podporován je pouze režim "full"; klíčové slovo numpy mode není přijímáno (jiné režimy lze získat krájením úplného výsledku). Výstupní délka je len(a) + len(v) - 1.

Polynomy¶

numpy.polyfit(x: ndarray | list | tuple, y: ndarray | list | tuple, deg: int) → ndarray¶

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Proloží body dat (x, y) polynomem stupně deg metodou nejmenších čtverců a vrátí koeficienty polynomu (od nejvyššího stupně). Je-li x vynecháno, použije se range(len(y)). Vyvolá ValueError, pokud se délky x a y liší.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Vyhodnotí polynom, jehož koeficienty jsou p (od nejvyššího stupně), v bodě x. Je-li x skalár, vrátí se float, jinak ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Načte pole dříve zapsané pomocí save ze souboru file (platformově nezávislý formát .npy od numpy). Endianita se převádí za běhu, pokud se pořadí bajtů souboru liší od pořadí hostitele.

numpy.loadtxt(file: str, *, delimiter: str | None = None, comments: str = '#', max_rows: int = -1, usecols: int | ndarray | list | tuple | None = None, dtype: int = float, skiprows: int = 0) → ndarray¶: Načte číselná data z textového souboru file a vrátí je jako ndarray. delimiter je výchozí bílý znak; comments je značka řádkového komentáře; max_rows omezuje počet načtených řádků dat (-1 pro všechny); usecols vybírá sloupce podle indexu; skiprows přeskočí tolik úvodních řádků. Není-li dtype float, hodnoty se konvertují zaokrouhlením.

numpy.save(file: str, a: ndarray) → None¶: Uloží a do souboru file v platformově nezávislém formátu .npy od numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Zapíše a do souboru file jako text. delimiter odděluje hodnoty v rámci řádku; header a footer, jsou-li zadány, se zapíší před/za data, každý s prefixem comments. Hodnoty se zapisují jako čísla s plovoucí desetinnou čárkou.

Pomocné funkce pro komplexní čísla¶

Tyto funkce jsou dostupné pouze tehdy, byl-li ulab zkompilován s podporou komplexních čísel (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Vrátí reálnou část val. Pro vstup reálného dtype vrátí kopii zachovávající dtype; pro komplexní vstup vrátí float ndarray.

numpy.imag(val: ndarray) → ndarray¶: Vrátí imaginární část val. Pro vstup reálného dtype vrátí pole nul se stejným dtype; pro komplexní vstup vrátí float ndarray.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Vrátí komplexně sdružené číslo val. Reálné vstupy se vracejí beze změny.

numpy.sort_complex(a: ndarray) → ndarray¶: Seřadí 1-D pole a nejprve podle reálné části, poté podle imaginární části. Výsledek je vždy komplexního dtype, i když a bylo reálné.

Univerzální funkce¶

Prvkové matematické funkce. Každá přijímá skalár nebo ndarray a vrací výsledek odpovídajícího tvaru (float skalár pro skalární vstup, ndarray pro polní vstup). Je-li volána s ndarray, výsledkem je nové ndarray s plovoucí desetinnou čárkou; lze předat volitelné klíčové slovo out pro zápis výsledku do předem alokovaného float ndarray stejné velikosti.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Vypočítá inverzní kosinus (arkuskosinus) každého prvku x; výsledek je v radiánech.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Vypočítá inverzní hyperbolický kosinus každého prvku x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Vypočítá dvouargumentový inverzní tangens atan2(y, x) po prvcích; podporuje broadcasting mezi dvěma vstupy.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Zaokrouhlí prvky ndarray x na zadaný počet desetinných míst decimals; první argument musí být ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Vypočítá inverzní sinus (arkussinus) každého prvku x; výsledek je v radiánech.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Vypočítá inverzní hyperbolický sinus každého prvku x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Vypočítá inverzní tangens (arkustangens) každého prvku x; výsledek je v radiánech.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Vypočítá inverzní hyperbolický tangens každého prvku x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Vypočítá strop (nejmenší celé číslo, které není menší než hodnota) každého prvku x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Vypočítá kosinus každého prvku x (v radiánech).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Vypočítá hyperbolický kosinus každého prvku x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Převede každý prvek x z radiánů na stupně.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Vypočítá exponenciálu e**x každého prvku x; při komplexním vstupu může vrátit komplexní ndarray (je-li povolena podpora komplexních čísel).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Vypočítá exp(x) - 1 každého prvku x se zlepšenou přesností v okolí nuly.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Vypočítá podlahu (největší celé číslo, které není větší než hodnota) každého prvku x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: Vypočítá přirozený logaritmus každého prvku x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Vypočítá dekadický logaritmus každého prvku x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Vypočítá dvojkový logaritmus každého prvku x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Převede každý prvek x ze stupňů na radiány.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Vypočítá sinus každého prvku x (v radiánech).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Vypočítá normalizovanou funkci sinc sin(pi*x) / (pi*x) každého prvku x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Vypočítá hyperbolický sinus každého prvku x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Vypočítá druhou odmocninu každého prvku x; předáním dtype=numpy.complex lze získat komplexní výsledky pro záporné reálné vstupy (je-li povolena podpora komplexních čísel).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Vypočítá tangens každého prvku x (v radiánech).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Vypočítá hyperbolický tangens každého prvku x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Vrátí volatelný objekt, který aplikuje Python funkci f po prvcích na skalár, iterovatelnou strukturu nebo ndarray; otypes vybírá výstupní dtype (výchozí float).

Konstanty¶

numpy.e: float¶: Eulerovo číslo \(e \approx 2.71828\).

numpy.pi: float¶: \(\pi \approx 3.14159\).

numpy.inf: float¶: Kladné nekonečno s plovoucí desetinnou čárkou dle IEEE-754.

numpy.nan: float¶: „Není číslo“ (not a number) s plovoucí desetinnou čárkou dle IEEE-754.

numpy.bool: int¶: Dtype kód pro booleovská pole (uložená jako uint8).

numpy.uint8: int¶: Dtype kód pro bezznaménková 8bitová celočíselná pole.

numpy.int8: int¶: Dtype kód pro znaménková 8bitová celočíselná pole.

numpy.uint16: int¶: Dtype kód pro bezznaménková 16bitová celočíselná pole.

numpy.int16: int¶: Dtype kód pro znaménková 16bitová celočíselná pole.

numpy.float: int¶: Dtype kód pro 32bitová pole s plovoucí desetinnou čárkou.

numpy — operace s poli kompatibilní s numpy¶