`numpy` — operații pe tablouri compatibile numpy¶

Submodulul numpy al ulab oferă un API compatibil cu numpy construit în jurul tipului de tablou n-dimensional ndarray. Implementează un subset selectat din numpy din CPython: construcția tablourilor, operații matematice element cu element, reduceri și statistici, algebră liniară, transformate Fourier (FFT), generarea de numere aleatoare, ajustarea polinomială și operații I/O de bază.

Submodulul este importat în mod convențional ca 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)))

Fiecare argument dtype este una dintre constantele întregi expuse la nivel de modul: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (valoarea implicită) și (atunci când suportul pentru numere complexe este compilat) numpy.complex. Tipul rezultat ndarray se referă la numpy.ndarray.

Submodule¶

clasa `ndarray` — tabloul n-dimensional¶

ndarray este containerul n-dimensional, conștient de dtype, aflat în centrul numpy / ulab. Datele sunt stocate într-un bloc contiguu a cărui interpretare este descrisă de un mic antet (dtype, shape, strides, ndim, itemsize). Multe operații – reshape, transpose, secționarea – doar ajustează acest antet și de aceea sunt foarte ieftine; metodele care alocă spațiu nou de stocare (copy, flatten, majoritatea operațiilor aritmetice) returnează un tablou dens nou.

Același tip este accesibil ca ulab.ndarray, numpy.ndarray și (în cadrul acestei pagini) simplu ca ndarray.

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

Creează un nou ndarray.

Parametrii:

values – Datele sursă. Fie un alt ndarray (care este copiat în profunzime, cu conversie de tip dacă dtype diferă), fie orice obiect iterabil MicroPython. Iterabilele imbricate produc tablouri multi-dimensionale; iterabilele interioare trebuie să aibă toate aceeași lungime, altfel se generează o eroare ValueError.
dtype – Tipul elementelor pentru noul tablou. Una dintre constantele întregi de cod de tip expuse de numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float și – atunci când este suportat – numpy.complex), sau o instanță dtype. Valoarea implicită este numpy.float.

Funcția fabrică numpy.array este modalitatea convențională de a crea un ndarray; ea redirecționează către acest constructor.

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

Inversează ordinea octeților fiecărui element. Pentru tablourile uint16, int16, float și complex aceasta inversează ordinea octeților per element, ceea ce este util la consumarea datelor de la periferice a căror endianness nu corespunde celei a microcontrolerului. Pentru tipurile dtype de un singur octet (bool, uint8, int8) aceasta nu are niciun efect și returnează o vizualizare sau o copie.

Dacă inplace este False (valoarea implicită), se returnează un nou ndarray, iar originalul rămâne neatins. Dacă inplace este True, octeții lui self sunt inversați pe loc și se returnează o vizualizare a lui self.

copy() → ndarray¶: Returnează o copie nouă, densă și în profunzime a tabloului. Copia deține propriile sale date; modificările aduse acesteia nu afectează originalul.

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

Returnează o copie unidimensională nouă a tabloului.

Parametrii:: order – 'C' (valoarea implicită) parcurge datele în ordine C (ultima axă variază cel mai rapid); 'F' le parcurge în ordine Fortran (prima axă variază cel mai rapid).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Returnează o vizualizare a tabloului cu o formă nouă. Numărul total de elemente trebuie să rămână neschimbat, altfel se generează o eroare ValueError. Disponibilă doar când ULAB_MAX_DIMS > 1. Echivalentă cu atribuirea către shape.

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

Sortează tabloul pe loc.

Parametrii:: axis – Axa de-a lungul căreia se sortează. -1 (valoarea implicită) sortează de-a lungul ultimei axe; None aplatizează mai întâi tabloul și apoi îl sortează.

tobytes() → bytearray¶: Returnează un bytearray care creează un alias către tamponul (buffer) de date subiacent al tabloului. Scrierile prin intermediul bytearray-ului returnat modifică tabloul pe loc. Generează ValueError dacă tabloul nu este dens (de exemplu, o vizualizare secționată).

tolist() → list¶: Returnează conținutul tabloului ca o list Python (eventual imbricată). Adâncimea imbricării este egală cu ndim.

transpose() → ndarray¶: Returnează transpusa tabloului (axele inversate). Pentru tablourile unidimensionale aceasta returnează self. Disponibilă doar când ULAB_MAX_DIMS > 1. Atributul T este o prescurtare pentru această metodă.

dtype: dtype | int¶: Tipul de date al elementelor tabloului. Returnează o instanță dtype atunci când firmware-ul este compilat cu ULAB_HAS_DTYPE_OBJECT activat, altfel codul de tip subiacent de un singur caracter sub formă de întreg.

flat: flatiter¶: Un iterator plat care produce fiecare element al tabloului în ordine C. Spre deosebire de flatten(), iterarea flat nu alocă un tablou nou.

itemsize: int¶: Dimensiunea în octeți a unui singur element al tabloului, derivată din dtype.

ndim: int¶: Numărul de dimensiuni ale tabloului (lungimea lui shape).

shape: tuple[int, ...]¶: Lungimile tabloului de-a lungul fiecărei axe. Atribuirea unui tuplu către shape reformează tabloul pe loc (echivalent cu reshape()).

size: int¶: Numărul total de elemente din tablou (produsul lui shape).

strides: tuple[int, ...]¶: Numărul de octeți cu care trebuie avansat în memorie de-a lungul fiecărei axe pentru a ajunge la următorul element de-a lungul acelei axe.

T: ndarray¶: Transpusa tabloului; echivalentă cu transpose().

real: ndarray¶: Partea reală a unui tablou complex, returnată ca un ndarray de tip float. Pentru tablourile reale aceasta este o copie a lui self cu același dtype. Disponibilă doar când firmware-ul a fost compilat cu suport pentru numere complexe.

imag: ndarray¶: Partea imaginară a unui tablou complex, returnată ca un ndarray de tip float. Pentru tablourile reale aceasta este un tablou de zerouri cu același dtype ca self. Disponibilă doar când firmware-ul a fost compilat cu suport pentru numere complexe.

Operatori suportați¶

Instanțele ndarray suportă următorii operatori. Operatorii binari aplică broadcasting operanzilor lor conform regulilor standard de broadcasting din numpy și respectă regulile de conversie ascendentă din numpy (de exemplu, uint8 + int8 => int16, uint16 + int16 => float); operațiile care implică un operand complex produc un rezultat complex.

Aritmetici (binari): +, -, *, /, //, %, **. Sunt de asemenea suportați operanzii reflectați (din dreapta) și variantele pe loc +=, -=, *=, /=, %=, **=. Sunt acceptate atât formele ndarray-cu-ndarray, cât și ndarray-cu-scalar. Împărțirea cu parte întreagă (//) și operatorul modulo (%) nu sunt implementate pentru tablourile complex.

Comparație: ==, !=, <, <=, >, >=. Fiecare returnează un ndarray boolean cu forma rezultată din broadcasting.

La nivel de biți (doar tablouri de întregi): &, |, ^. Aplicarea acestora unui tablou float sau complex generează TypeError.

Unari: + (returnează o copie), - (negare; pe tipurile dtype fără semn valorile se rotunjesc modulo \(2^N\)), abs() (valoarea absolută element cu element; pe tipurile dtype fără semn returnează o copie fără calcul), ~ (inversare la nivel de biți, doar tipuri dtype de întregi), len() (returnează lungimea primei axe).

Indexare și secționare: a[i], a[i, j, ...], a[start:stop:step], indexarea cu mască booleană (a[mask]) și indexarea cu tablou de întregi (fancy) sunt toate suportate atât la citire, cât și la scriere.

Iterare: Iterarea peste un ndarray produce sub-tablouri de-a lungul primei axe (câte un element pe rând pentru tablourile 1-D). Folosiți flat pentru a itera peste fiecare element scalar, indiferent de dimensionalitate.

Operatorul de înmulțire matriceală @ nu este implementat; folosiți în schimb numpy.dot (np.dot(a, b)).

Operatorii de deplasare (<<, >>) nu sunt implementați la nivel de operator. Folosiți numpy.left_shift și numpy.right_shift pentru deplasări de întregi element cu element.

Construcția tablourilor¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Construiește un nou ndarray dintr-un iterabil imbricat de numere. Constructor alternativ echivalent pentru numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Returnează valori distanțate uniform pe intervalul semideschis [start, stop). Dacă se furnizează un singur argument pozițional, acesta este tratat ca stop cu start = 0. Dacă dtype este omis, este dedus din intrări (întreg dacă toate dintre start, stop, step sunt întregi și se află în interval).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Dacă a este deja un ndarray al cărui dtype corespunde cu dtype (sau dtype este None), returnează a neschimbat; altfel creează un tablou nou (cu conversia de dtype solicitată, dacă este dată). Iterabilele sunt convertite ca în numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Concatenează o secvență de ndarray de-a lungul unei axe existente axis. Toate tablourile de intrare trebuie să aibă același dtype, ndim și aceeași formă pe fiecare axă în afară de axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Pentru un a 2-D, returnează un tablou 1-D conținând a k-a diagonală. Pentru un a 1-D, returnează un tablou pătrat 2-D cu a plasat pe a k-a diagonală. k poate fi pozitiv (deasupra diagonalei principale) sau negativ (sub aceasta).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Alias pentru zeros; returnează un tablou umplut cu zerouri, de forma shape și dtype-ul dtype. (ulab nu lasă tamponul (buffer) neinițializat.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Returnează un tablou 2-D de N x M (pătrat N x N dacă M este None) cu valori de unu pe a k-a diagonală și zerouri în rest.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Interpretează un obiect cu protocol de tampon (buffer) ca un ndarray 1-D de dtype dtype. count este numărul de elemente de citit (-1 citește toate elementele disponibile); offset sare peste atât de mulți octeți la începutul tamponului (buffer).

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Returnează un tablou nou de forma shape și dtype-ul dtype cu fiecare element setat la fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Returnează num eșantioane distanțate uniform pe intervalul închis [start, stop] (sau semideschis dacă endpoint este False). Când retstep este True, returnează un tuplu (samples, step). start/stop complecși produc un tablou complex (când suportul pentru numere complexe este activat).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Returnează num eșantioane distanțate uniform pe o scală logaritmică: rezultatul începe la base ** start și se termină la base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Returnează un tuplu de matrice de coordonate dintr-o secvență de tablouri unidimensionale de coordonate. Cu indexing 'xy' (valoarea implicită), primele două intrări sunt tratate ca coordonate carteziene, iar axele lor de ieșire sunt interschimbate; cu 'ij' se folosește indexarea în stil matriceal. Implementarea corespunde echivalentului NumPy cu copy=True și sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Returnează un tablou nou de forma shape și dtype-ul dtype umplut cu valori de unu.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Returnează un tablou nou de forma shape și dtype-ul dtype umplut cu zerouri.

Inspectare / afișare¶

numpy.get_printoptions() → dict¶: Returnează opțiunile curente de afișare a tablourilor ca un dicționar cu cheile threshold și edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Setează opțiunile de afișare a tablourilor. threshold este numărul maxim de elemente ale tabloului afișate integral; edgeitems este numărul de elemente afișate la fiecare capăt al unei axe atunci când tabloul este rezumat.

numpy.ndinfo(array: ndarray) → None¶: Afișează informații de diagnosticare (shape, strides, dtype, itemsize, …) despre array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Returnează numărul de elemente ale lui a de-a lungul axei axis; dacă axis este None, returnează numărul total de elemente (produsul lui ndarray.shape).

Comparație¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Limitează valorile lui a astfel încât a_min <= result <= a_max. Echivalent cu maximum(a_min, minimum(a, a_max)); broadcasting-ul respectă aceleași reguli ca minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: x1 == x2 element cu element; returnează un ndarray boolean (sau un scalar bool dacă ambele intrări sunt scalari). Oferit pentru portabilitate – operatorul == pe tablouri dă același rezultat.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: x1 != x2 element cu element; corespondentul boolean al lui equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Returnează un tablou boolean (sau scalar) care este True acolo unde intrarea este finită. Intrările întregi sunt întotdeauna finite.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Returnează un tablou boolean (sau scalar) care este True acolo unde intrarea este infinită. Intrările întregi nu sunt niciodată infinite.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Maximul element cu element a două tablouri / scalari. Argumentele sunt combinate prin broadcasting; dacă tipurile dtype diferă, ieșirea este convertită ascendent.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Minimul element cu element a două tablouri / scalari; corespondentul lui maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Returnează un tuplu de ndarray, câte unul pentru fiecare dimensiune a lui a, conținând indicii elementelor nenule ale lui a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Returnează un ndarray ale cărui elemente provin din x acolo unde condition este adevărat și din y în caz contrar. Cele trei intrări sunt combinate prin broadcasting; dtype-ul ieșirii este conversia ascendentă a lui x și y.

Reduceri numerice¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Verifică dacă toate elementele de-a lungul axei axis se evaluează la True. Cu axis=None (valoarea implicită) se verifică tabloul aplatizat și se returnează un singur bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Verifică dacă vreun element de-a lungul axei axis se evaluează la True. Cu axis=None se verifică tabloul aplatizat.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Returnează indexul elementului maxim de-a lungul axei axis. Cu axis=None tabloul este aplatizat și se returnează un singur întreg.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Returnează indexul elementului minim de-a lungul axei axis. Cu axis=None tabloul este aplatizat și se returnează un singur întreg.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Returnează un ndarray de indici întregi fără semn ale cărui elemente sortează a în ordine crescătoare de-a lungul axei axis. Dtype-ul ieșirii este uint16, deci nicio axă nu poate depăși 65535 de elemente. axis=None nu este suportat.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Returnează produsul vectorial a două tablouri 1-D de lungime 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Returnează a n-a diferență directă discretă a lui a de-a lungul axei axis. n trebuie să fie în 0..9 (matricea de diferențiere este stocată într-un int8); lungimea lui axis scade cu n. Cuvintele-cheie numpy prepend și append nu sunt implementate.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Returnează un tablou nou cu ordinea elementelor inversată de-a lungul axei axis; cu axis=None tabloul este inversat de-a lungul fiecărei axe.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Returnează elementul maxim de-a lungul axei axis. Cu axis=None (valoarea implicită) tabloul aplatizat este redus la un scalar. Cuvântul-cheie numpy out nu este implementat.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Returnează elementul minim de-a lungul axei axis; corespondentul lui max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Returnează media aritmetică de-a lungul axei axis. Cu axis=None (valoarea implicită) media tabloului aplatizat este returnată ca un float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Returnează mediana de-a lungul axei axis. Cu axis=None tabloul este aplatizat mai întâi. Dtype-ul ieșirii este întotdeauna float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Returnează a cu elementele sale rotite (deplasate ciclic) cu shift poziții. Cu axis=None (valoarea implicită) tabloul este aplatizat mai întâi. Deplasările negative rotesc în direcția opusă.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Returnează o copie sortată a lui a de-a lungul axei axis folosind sortarea cu heap. Cu axis=None tabloul este aplatizat mai întâi. Cuvintele-cheie numpy kind și order nu sunt implementate.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Returnează abaterea standard de-a lungul axei axis. ddof reprezintă gradele delta de libertate – divizorul folosit este N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Returnează suma de-a lungul axei axis. Cu axis=None totalul tabloului aplatizat este returnat ca un scalar.

Statistici¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Numără aparițiile fiecărei valori din tabloul unidimensional de întregi nenegativi x. Dtype-ul lui x trebuie să fie uint8 sau uint16. Dacă weights este dat, fiecare element din x contribuie cu ponderea sa corespunzătoare în loc de 1, iar ieșirea este de dtype float; altfel ieșirea este de dtype uint16. Dacă minlength este dat, tabloul de ieșire are cel puțin atât de multe elemente (elementele suplimentare sunt zero).

numpy.trace(m: ndarray) → int | float¶: Returnează suma elementelor de pe diagonala matricei pătrate m. Tipul returnat urmează dtype-ul lui m (tablourile de întregi produc un întreg, cele float un float).

Transformare¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Returnează secțiuni ale lui a selectate de-a lungul axei axis de condiția booleană condition. Cu axis=None se folosește tabloul aplatizat.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Returnează o copie a lui a cu elementele de la indices eliminate de-a lungul axei axis. Cu axis=None tabloul este aplatizat mai întâi. Indicii negativi se numără de la sfârșitul lui axis; indices este sortat intern înainte de eliminare.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Returnează produsul scalar a două tablouri. Pentru două tablouri 1-D acesta este produsul interior (un scalar float). Pentru tablourile 2-D acesta este înmulțirea matriceală; dimensiunile interioare trebuie să corespundă. Rezultatul este întotdeauna de dtype float.

Aproximare¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Interpolare liniară unidimensională. xp trebuie să fie un tablou 1-D monoton crescător de valori independente; fp conține valorile dependente corespunzătoare; x sunt punctele în care este evaluat interpolantul. left și right suprascriu valoarea returnată pentru x < xp[0] și, respectiv, x > xp[-1] (valori implicite: fp[0] și fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integrează y folosind regula trapezelor compusă. Dacă x este dat, acesta furnizează pozițiile eșantioanelor corespunzătoare lui y; altfel se folosește spațierea dx. y (și x) trebuie să fie 1-D.

Selecție¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Preia elemente din a la indicii dați indices de-a lungul axei axis. Cu axis=None se folosește tabloul aplatizat. mode selectează comportamentul în afara limitelor: "raise" (implicit – generează ValueError), "wrap" (modulo lungimea axei) sau "clip" (limitează la intervalul valid; indicii negativi nu sunt permiși). Dacă out este dat, rezultatul este scris în el.

La nivel de biți¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: ȘI logic la nivel de biți, element cu element, a două tablouri de întregi; broadcasting-ul este suportat. Un dtype non-întreg generează o excepție.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: SAU logic la nivel de biți, element cu element, a două tablouri de întregi.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: SAU exclusiv la nivel de biți, element cu element, a două tablouri de întregi.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Deplasarea la nivel de biți, element cu element, a lui x1 la stânga cu x2 biți; ambele tablouri trebuie să aibă dtype de întregi.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Deplasarea la nivel de biți, element cu element, a lui x1 la dreapta cu x2 biți; ambele tablouri trebuie să aibă dtype de întregi.

Filtrare¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Returnează convoluția liniară discretă a două tablouri 1-D. Este suportat doar modul "full"; cuvântul-cheie numpy mode nu este acceptat (alte moduri pot fi obținute prin secționarea rezultatului complet). Lungimea ieșirii este len(a) + len(v) - 1.

Polinom¶

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Ajustează un polinom de grad deg la punctele de date (x, y) prin metoda celor mai mici pătrate și returnează coeficienții polinomului (cel mai mare grad primul). Dacă x este omis, se folosește range(len(y)). Generează ValueError dacă lungimile lui x și y diferă.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Evaluează polinomul ai cărui coeficienți sunt p (cel mai mare grad primul) în x. Dacă x este un scalar, se returnează un float, altfel un ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Citește un tablou scris anterior cu save din file (formatul .npy independent de platformă al numpy). Endianness-ul este convertit din mers dacă ordinea octeților din fișier diferă de cea a gazdei.

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¶: Citește date numerice dintr-un file text și le returnează ca un ndarray. delimiter are ca valoare implicită spațiul alb; comments este marcatorul de comentariu de linie; max_rows limitează numărul de rânduri de date citite (-1 pentru toate); usecols selectează coloanele după index; skiprows sare peste atât de multe rânduri inițiale. Dacă dtype nu este float, valorile sunt convertite prin rotunjire.

numpy.save(file: str, a: ndarray) → None¶: Salvează a în file în formatul .npy independent de platformă al numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Scrie a în file ca text. delimiter separă valorile dintr-un rând; header și footer, dacă sunt furnizate, sunt scrise înainte/după date, fiecare precedat de comments. Valorile sunt scrise în virgulă mobilă.

Ajutoare pentru numere complexe¶

Aceste funcții sunt disponibile doar când ulab a fost compilat cu suport pentru numere complexe (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Returnează partea reală a lui val. Pentru o intrare cu dtype real, returnează o copie care păstrează dtype-ul; pentru o intrare complexă, returnează un ndarray float.

numpy.imag(val: ndarray) → ndarray¶: Returnează partea imaginară a lui val. Pentru o intrare cu dtype real, returnează un tablou de zerouri cu același dtype; pentru o intrare complexă, returnează un ndarray float.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Returnează conjugata complexă a lui val. Intrările cu valori reale sunt returnate neschimbate.

numpy.sort_complex(a: ndarray) → ndarray¶: Sortează tabloul 1-D a mai întâi după partea reală, apoi după partea imaginară. Rezultatul este întotdeauna de dtype complex, chiar dacă a avea valori reale.

Funcții universale¶

Funcții matematice element cu element. Fiecare acceptă un scalar sau un ndarray și returnează un rezultat de formă corespunzătoare (un scalar float pentru intrare scalară, un ndarray pentru intrare de tip tablou). Când sunt apelate cu un ndarray, rezultatul este un nou ndarray în virgulă mobilă; un cuvânt-cheie out opțional poate fi transmis pentru a scrie rezultatul într-un ndarray float prealocat de aceeași dimensiune.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Calculează cosinusul invers (arccosinus) al fiecărui element al lui x; rezultatul este în radiani.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Calculează cosinusul hiperbolic invers al fiecărui element al lui x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Calculează tangenta inversă cu două argumente atan2(y, x) element cu element; suportă broadcasting între cele două intrări.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Rotunjește elementele ndarray-ului x la numărul dat de decimals; primul argument trebuie să fie un ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Calculează sinusul invers (arcsinus) al fiecărui element al lui x; rezultatul este în radiani.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Calculează sinusul hiperbolic invers al fiecărui element al lui x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Calculează tangenta inversă (arctangenta) a fiecărui element al lui x; rezultatul este în radiani.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Calculează tangenta hiperbolică inversă a fiecărui element al lui x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Calculează partea întreagă superioară (cel mai mic întreg nu mai mic decât valoarea) a fiecărui element al lui x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Calculează cosinusul fiecărui element al lui x (în radiani).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Calculează cosinusul hiperbolic al fiecărui element al lui x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Convertește fiecare element al lui x din radiani în grade.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Calculează exponențiala e**x a fiecărui element al lui x; poate returna un ndarray complex când i se dă intrare complexă (dacă suportul pentru numere complexe este activat).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Calculează exp(x) - 1 a fiecărui element al lui x cu precizie îmbunătățită în apropierea valorii zero.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Calculează partea întreagă inferioară (cel mai mare întreg nu mai mare decât valoarea) a fiecărui element al lui x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: Calculează logaritmul natural al fiecărui element al lui x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Calculează logaritmul în baza 10 al fiecărui element al lui x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Calculează logaritmul în baza 2 al fiecărui element al lui x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Convertește fiecare element al lui x din grade în radiani.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Calculează sinusul fiecărui element al lui x (în radiani).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Calculează funcția sinc normalizată sin(pi*x) / (pi*x) a fiecărui element al lui x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Calculează sinusul hiperbolic al fiecărui element al lui x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Calculează rădăcina pătrată a fiecărui element al lui x; transmiteți dtype=numpy.complex pentru a obține rezultate complexe pentru intrări reale negative (dacă suportul pentru numere complexe este activat).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Calculează tangenta fiecărui element al lui x (în radiani).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Calculează tangenta hiperbolică a fiecărui element al lui x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Returnează un obiect apelabil care aplică funcția Python f element cu element unui scalar, unui iterabil sau unui ndarray; otypes selectează dtype-ul ieșirii (implicit float).

Constante¶

numpy.e: float¶: Numărul lui Euler \(e \approx 2.71828\).

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

numpy.inf: float¶: Infinit pozitiv în virgulă mobilă IEEE-754.

numpy.nan: float¶: Valoare „not a number” în virgulă mobilă IEEE-754.

numpy.bool: int¶: Cod dtype pentru tablouri booleene (stocate ca uint8).

numpy.uint8: int¶: Cod dtype pentru tablouri de întregi fără semn pe 8 biți.

numpy.int8: int¶: Cod dtype pentru tablouri de întregi cu semn pe 8 biți.

numpy.uint16: int¶: Cod dtype pentru tablouri de întregi fără semn pe 16 biți.

numpy.int16: int¶: Cod dtype pentru tablouri de întregi cu semn pe 16 biți.

numpy.float: int¶: Cod dtype pentru tablouri în virgulă mobilă pe 32 de biți.

numpy — operații pe tablouri compatibile numpy¶