`numpy` — numpy-yhteensopivat taulukko-operaatiot¶

ulab-moduulin numpy-alimoduuli tarjoaa numpy-yhteensopivan API:n, joka rakentuu n-ulotteisen taulukkotyypin ndarray ympärille. Se toteuttaa huolellisesti valitun osajoukon CPythonin numpy-kirjastosta: taulukoiden luonnin, alkioittaisen matematiikan, redusoinnit ja tilastot, lineaarialgebran, FFT:t, satunnaislukujen generoinnin, polynomien sovituksen ja perus-I/O:n.

Alimoduuli tuodaan tavanomaisesti nimellä 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)))

Kukin dtype-argumentti on yksi moduulitasolla julkaistuista kokonaislukuvakioista: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (oletus) ja (kun kompleksilukutuki on käännetty mukaan) numpy.complex. Tulostyyppi ndarray viittaa tyyppiin numpy.ndarray.

Alimoduulit¶

luokka `ndarray` — n-ulotteinen taulukko¶

ndarray on n-ulotteinen, dtype-tietoinen säiliö, joka muodostaa numpy- / ulab-kirjastojen ytimen. Data tallennetaan yhtenäiseen lohkoon, jonka tulkinta kuvataan pienellä otsikolla (dtype, shape, strides, ndim, itemsize). Monet operaatiot – reshape, transpose, viipalointi – vain muokkaavat tätä otsikkoa ja ovat siksi erittäin edullisia; metodit, jotka varaavat uutta muistia (copy, flatten, useimmat aritmeettiset operaatiot), palauttavat uuden tiheän taulukon.

Sama tyyppi on tavoitettavissa nimillä ulab.ndarray, numpy.ndarray ja (tällä sivulla) yksinkertaisesti ndarray.

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

Luo uusi ndarray.

Parametrit:

values – Lähdedata. Joko toinen ndarray (joka kopioidaan syvällisesti tyyppimuunnoksineen, jos dtype eroaa) tai mikä tahansa MicroPython-iteroitava. Sisäkkäiset iteroitavat tuottavat moniulotteisia taulukoita; sisempien iteroitavien on kaikkien oltava saman pituisia, muutoin nostetaan ValueError.
dtype – Uuden taulukon alkiotyyppi. Yksi numpy-kirjaston julkaisemista tyyppikoodikokonaisluvuista (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float ja – kun tuettu – numpy.complex) tai dtype-ilmentymä. Oletuksena numpy.float.

Tehdasfunktio numpy.array on tavanomainen tapa luoda ndarray; se välittää kutsun tälle konstruktorille.

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

Vaihda jokaisen alkion tavujärjestys. Taulukoille tyyppiä uint16, int16, float ja complex tämä kääntää kunkin alkion tavujärjestyksen, mikä on hyödyllistä kulutettaessa dataa oheislaitteilta, joiden endiaanisuus ei vastaa mikrokontrollerin omaa. Yksitavuisille dtype-tyypeille (bool, uint8, int8) tämä on tyhjä operaatio, joka palauttaa näkymän tai kopion.

Jos inplace on False (oletus), palautetaan uusi ndarray ja alkuperäinen jätetään koskemattomaksi. Jos inplace on True, self-objektin tavut vaihdetaan paikallaan ja palautetaan näkymä self-objektista.

copy() → ndarray¶: Palauta uusi tiheä, syvä kopio taulukosta. Kopio omistaa oman datansa; sen muokkaaminen ei vaikuta alkuperäiseen.

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

Palauta uusi yksiulotteinen kopio taulukosta.

Parametrit:: order – 'C' (oletus) käy datan läpi C-järjestyksessä (viimeinen akseli vaihtuu nopeimmin); 'F' käy sen läpi Fortran-järjestyksessä (ensimmäinen akseli vaihtuu nopeimmin).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Palauta taulukosta näkymä uudella muodolla. Alkioiden kokonaismäärän on pysyttävä muuttumattomana, muutoin nostetaan ValueError. Käytettävissä vain kun ULAB_MAX_DIMS > 1. Vastaa sijoittamista attribuuttiin shape.

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

Lajittele taulukko paikallaan.

Parametrit:: axis – Akseli, jota pitkin lajitellaan. -1 (oletus) lajittelee viimeistä akselia pitkin; None litistää taulukon ensin ja lajittelee sitten.

tobytes() → bytearray¶: Palauta bytearray, joka aliasoi taulukon taustalla olevan datapuskurin. Kirjoitukset palautetun bytearray-objektin kautta muokkaavat taulukkoa paikallaan. Nostaa ValueError-poikkeuksen, jos taulukko ei ole tiheä (esim. viipaloitu näkymä).

tolist() → list¶: Palauta taulukon sisältö (mahdollisesti sisäkkäisenä) Python-list-objektina. Sisäkkäisyyden syvyys vastaa attribuuttia ndim.

transpose() → ndarray¶: Palauta taulukon transpoosi (akselit käännettyinä). Yksiulotteisille taulukoille tämä palauttaa self. Käytettävissä vain kun ULAB_MAX_DIMS > 1. Attribuutti T on lyhennys tälle metodille.

dtype: dtype | int¶: Taulukon alkioiden tietotyyppi. Palauttaa dtype-ilmentymän, kun laiteohjelmisto on käännetty ULAB_HAS_DTYPE_OBJECT käytössä, muutoin taustalla olevan yksimerkkisen tyyppikoodin kokonaislukuna.

flat: flatiter¶: Litteä iteraattori, joka tuottaa taulukon jokaisen alkion C-järjestyksessä. Toisin kuin flatten(), flat-iteroinnissa ei varata uutta taulukkoa.

itemsize: int¶: Yksittäisen taulukkoalkion koko tavuina, johdettuna attribuutista dtype.

ndim: int¶: Taulukon ulottuvuuksien määrä (attribuutin shape pituus).

shape: tuple[int, ...]¶: Taulukon pituudet kunkin akselin suunnassa. Monikon sijoittaminen attribuuttiin shape muokkaa taulukon muodon paikallaan (vastaa metodia reshape()).

size: int¶: Taulukon alkioiden kokonaismäärä (attribuutin shape tulo).

strides: tuple[int, ...]¶: Tavujen määrä, jonka verran muistissa siirrytään kunkin akselin suunnassa seuraavaan alkioon kyseisellä akselilla.

T: ndarray¶: Taulukon transpoosi; vastaa metodia transpose().

real: ndarray¶: Kompleksitaulukon reaaliosa, palautettuna float-tyyppisenä ndarray-taulukkona. Reaalitaulukoille tämä on self-objektin kopio samalla dtype-tyypillä. Käytettävissä vain kun laiteohjelmisto on käännetty kompleksilukutuella.

imag: ndarray¶: Kompleksitaulukon imaginaariosa, palautettuna float-tyyppisenä ndarray-taulukkona. Reaalitaulukoille tämä on nollien taulukko, jolla on sama dtype kuin self-objektilla. Käytettävissä vain kun laiteohjelmisto on käännetty kompleksilukutuella.

Tuetut operaattorit¶

ndarray-ilmentymät tukevat seuraavia operaattoreita. Binäärioperaattorit lähettävät operandinsa (broadcast) numpyn standardien lähetyssääntöjen mukaisesti ja noudattavat numpyn ylöskorotussääntöjä (esim. uint8 + int8 => int16, uint16 + int16 => float); kompleksioperandin sisältävät operaatiot tuottavat kompleksisen tuloksen.

Aritmeettiset (binääriset): +, -, *, /, //, %, **. Myös heijastetut (oikeanpuoleiset) operandit ja paikalliset muunnokset +=, -=, *=, /=, %=, **= ovat tuettuja. Sekä ndarray-ndarray- että ndarray-skalaari-muodot hyväksytään. Kokonaislukujakoa (//) ja modulo-operaattoria (%) ei ole toteutettu complex-taulukoille.

Vertailu: ==, !=, <, <=, >, >=. Kukin palauttaa lähetetyn muodon (broadcast) mukaisen totuusarvoisen ndarray-taulukon.

Bittikohtaiset (vain kokonaislukutaulukot): &, |, ^. Näiden soveltaminen float- tai complex-taulukkoon nostaa TypeError-poikkeuksen.

Unaariset: + (palauttaa kopion), - (negaatio; etumerkittömillä dtype-tyypeillä arvot kiertyvät modulo \(2^N\)), abs() (alkioittainen itseisarvo; etumerkittömillä dtype-tyypeillä palauttaa kopion ilman laskentaa), ~ (bittikohtainen inversio, vain kokonaislukutyypit), len() (palauttaa ensimmäisen akselin pituuden).

Indeksointi ja viipalointi: a[i], a[i, j, ...], a[start:stop:step], totuusarvomaskilla indeksointi (a[mask]) ja kokonaislukutaulukolla (fancy) indeksointi ovat kaikki tuettuja sekä luvuissa että kirjoituksissa.

Iterointi: ndarray-taulukon iterointi tuottaa alitaulukoita ensimmäistä akselia pitkin (yksi alkio kerrallaan 1-ulotteisille taulukoille). Käytä attribuuttia flat iteroidaksesi jokaisen skalaarialkion yli ulottuvuudesta riippumatta.

Matriisikertolasku-operaattoria @ ei ole toteutettu; käytä sen sijaan funktiota numpy.dot (np.dot(a, b)).

Siirto-operaattoreita (<<, >>) ei ole toteutettu operaattoritasolla. Käytä funktioita numpy.left_shift ja numpy.right_shift alkioittaisiin kokonaislukusiirtoihin.

Taulukoiden luonti¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Rakenna uusi ndarray lukujen sisäkkäisestä iteroitavasta. Vastaava vaihtoehtoinen konstruktori tyypille numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Palauta tasavälisiä arvoja puoliavoimella välillä [start, stop). Jos vain yksi positionaalinen argumentti annetaan, sitä käsitellään stop-arvona ja start = 0. Jos dtype jätetään pois, se päätellään syötteistä (kokonaisluku jos kaikki start, stop, step ovat kokonaislukuja ja sallitulla alueella).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Jos a on jo ndarray, jonka dtype vastaa dtype-arvoa (tai dtype on None), palauta a muuttumattomana; muutoin luo uusi taulukko (pyydetyllä dtype-muunnoksella, jos annettu). Iteroitavat muunnetaan kuten funktiossa numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Yhdistä ndarray-taulukoiden jono olemassa olevaa axis-akselia pitkin. Kaikkien syötetaulukoiden on jaettava sama dtype, ndim ja muoto jokaisella muulla akselilla kuin axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Kaksiulotteiselle a-taulukolle palauta 1-ulotteinen taulukko, joka sisältää k:nnen lävistäjän. Yksiulotteiselle a-taulukolle palauta 2-ulotteinen neliötaulukko, jossa a on sijoitettu k:nnelle lävistäjälle. k voi olla positiivinen (päälävistäjän yläpuolella) tai negatiivinen (alapuolella).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Alias funktiolle zeros; palauttaa nollilla täytetyn taulukon muotoa shape ja tyyppiä dtype. (ulab ei jätä puskuria alustamatta.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Palauta 2-ulotteinen N x M -taulukko (neliö N x N, jos M on None), jossa on ykkösiä k:nnella lävistäjällä ja nollia muualla.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Tulkitse puskuriprotokollaa noudattava objekti dtype-tyypin dtype 1-ulotteisena ndarray-taulukkona. count on luettavien alkioiden määrä (-1 lukee kaikki saatavilla olevat alkiot); offset ohittaa kyseisen määrän tavuja puskurin alusta.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Palauta uusi taulukko muotoa shape ja tyyppiä dtype, jossa jokainen alkio on asetettu arvoon fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Palauta num tasavälistä näytettä suljetulla välillä [start, stop] (tai puoliavoimella, jos endpoint on False). Kun retstep on True, palauta monikko (samples, step). Kompleksinen start/stop tuottaa kompleksisen taulukon (kun kompleksilukutuki on käytössä).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Palauta num tasavälistä näytettä logaritmisella asteikolla: tulos alkaa arvosta base ** start ja päättyy arvoon base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Palauta monikko koordinaattimatriiseja yksiulotteisten koordinaattitaulukoiden jonosta. Arvolla indexing 'xy' (oletus) kahta ensimmäistä syötettä käsitellään karteesisina koordinaatteina ja niiden tulosakselit vaihdetaan keskenään; arvolla 'ij' käytetään matriisityylistä indeksointia. Toteutus vastaa NumPyn vastinetta arvoilla copy=True ja sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Palauta uusi ykkösillä täytetty taulukko muotoa shape ja tyyppiä dtype.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Palauta uusi nollilla täytetty taulukko muotoa shape ja tyyppiä dtype.

Tarkastelu / tulostus¶

numpy.get_printoptions() → dict¶: Palauta taulukon nykyiset tulostusasetukset sanakirjana, jonka avaimet ovat threshold ja edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Aseta taulukon tulostusasetukset. threshold on kokonaisuudessaan tulostettavien taulukkoalkioiden enimmäismäärä; edgeitems on akselin kummassakin päässä näytettävien alkioiden määrä, kun taulukko tiivistetään.

numpy.ndinfo(array: ndarray) → None¶: Tulosta diagnostista tietoa (muoto, askeleet, dtype, itemsize, …) taulukosta array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Palauta a-taulukon alkioiden määrä akselilla axis; jos axis on None, palauta alkioiden kokonaismäärä (attribuutin ndarray.shape tulo).

Vertailu¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Leikkaa a-taulukon arvot niin, että a_min <= result <= a_max. Vastaa lauseketta maximum(a_min, minimum(a, a_max)); lähetys (broadcast) noudattaa samoja sääntöjä kuin minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Alkioittainen x1 == x2; palauttaa totuusarvoisen ndarray-taulukon (tai bool-skalaarin, jos molemmat syötteet ovat skalaareja). Tarjottu siirrettävyyden vuoksi – ==-operaattori taulukoilla antaa saman tuloksen.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Alkioittainen x1 != x2; funktion equal totuusarvoinen vastine.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Palauta totuusarvotaulukko (tai -skalaari), joka on True siellä, missä syöte on äärellinen. Kokonaislukusyötteet ovat aina äärellisiä.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Palauta totuusarvotaulukko (tai -skalaari), joka on True siellä, missä syöte on ääretön. Kokonaislukusyötteet eivät ole koskaan äärettömiä.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Kahden taulukon / skalaarin alkioittainen maksimi. Argumentit lähetetään (broadcast) yhteen; jos dtype-tyypit eroavat, tulos korotetaan ylöspäin.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Kahden taulukon / skalaarin alkioittainen minimi; funktion maximum vastine.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Palauta monikko ndarray-taulukoita, yksi a-taulukon kutakin ulottuvuutta kohti, jotka sisältävät a-taulukon nollasta poikkeavien alkioiden indeksit.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Palauta ndarray, jonka alkiot tulevat x-taulukosta siellä, missä condition on tosi, ja muutoin y-taulukosta. Kolme syötettä lähetetään (broadcast) yhteen; tuloksen dtype on x- ja y-tyyppien ylöskorotus.

Numeeriset redusoinnit¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Testaa, ovatko kaikki axis-akselin alkiot arvoltaan True. Arvolla axis=None (oletus) testataan litistetty taulukko ja palautetaan yksi bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Testaa, onko jokin axis-akselin alkio arvoltaan True. Arvolla axis=None testataan litistetty taulukko.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Palauta maksimialkion indeksi axis-akselilla. Arvolla axis=None taulukko litistetään ja palautetaan yksi kokonaisluku.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Palauta minimialkion indeksi axis-akselilla. Arvolla axis=None taulukko litistetään ja palautetaan yksi kokonaisluku.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Palauta etumerkitön kokonaislukuindeksi-ndarray, jonka alkiot lajittelevat a-taulukon nousevaan järjestykseen axis-akselia pitkin. Tuloksen dtype on uint16, joten mikään akseli ei saa ylittää 65535 alkiota. axis=None ei ole tuettu.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Palauta kahden 3-pituisen 1-ulotteisen taulukon ristitulo.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Palauta a-taulukon n:s diskreetti eteenpäin-differenssi axis-akselia pitkin. n:n on oltava välillä 0..9 (differensiointistensiili tallennetaan int8-tyyppiin); axis-akselin pituus pienenee n:llä. numpyn prepend- ja append-avainsanoja ei ole toteutettu.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Palauta uusi taulukko, jossa alkioiden järjestys on käännetty axis-akselia pitkin; arvolla axis=None taulukko käännetään jokaisen akselin suunnassa.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Palauta maksimialkio axis-akselilla. Arvolla axis=None (oletus) litistetty taulukko redusoidaan skalaariksi. numpyn out-avainsanaa ei ole toteutettu.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Palauta minimialkio axis-akselilla; funktion max vastine.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Palauta aritmeettinen keskiarvo axis-akselilla. Arvolla axis=None (oletus) litistetyn taulukon keskiarvo palautetaan float-tyyppisenä.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Palauta mediaani axis-akselilla. Arvolla axis=None taulukko litistetään ensin. Tuloksen dtype on aina float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Palauta a, jonka alkiot on rullattu (syklisesti siirretty) shift paikkaa. Arvolla axis=None (oletus) taulukko litistetään ensin. Negatiiviset siirrot rullaavat vastakkaiseen suuntaan.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Palauta a-taulukon lajiteltu kopio axis-akselia pitkin käyttäen kekolajittelua. Arvolla axis=None taulukko litistetään ensin. numpyn kind- ja order-avainsanoja ei ole toteutettu.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Palauta keskihajonta axis-akselilla. ddof on delta-vapausasteet – käytetty jakaja on N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Palauta summa axis-akselilla. Arvolla axis=None litistetyn taulukon kokonaissumma palautetaan skalaarina.

Tilastot¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Laske kunkin arvon esiintymien määrä yksiulotteisessa, ei-negatiivisten kokonaislukujen taulukossa x. x-taulukon dtype-tyypin on oltava uint8 tai uint16. Jos weights annetaan, kukin x-taulukon alkio kontribuoi vastaavalla painollaan arvon 1 sijaan ja tulos on dtype-tyyppiä float; muutoin tulos on dtype-tyyppiä uint16. Jos minlength annetaan, tulostaulukossa on vähintään kyseinen määrä alkioita (ylimääräiset alkiot ovat nollia).

numpy.trace(m: ndarray) → int | float¶: Palauta neliömatriisin m lävistäjäalkioiden summa. Paluutyyppi seuraa m-taulukon dtype-tyyppiä (kokonaislukutaulukot tuottavat kokonaisluvun, float-taulukot floatin).

Muunna¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Palauta a-taulukon viipaleet, jotka on valittu axis-akselia pitkin totuusarvoisella condition-ehdolla. Arvolla axis=None käytetään litistettyä taulukkoa.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Palauta a-taulukon kopio, jossa kohdat indekseissä indices on poistettu axis-akselia pitkin. Arvolla axis=None taulukko litistetään ensin. Negatiiviset indeksit lasketaan axis-akselin lopusta; indices lajitellaan sisäisesti ennen poistoa.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Palauta kahden taulukon pistetulo. Kahdelle 1-ulotteiselle taulukolle tämä on sisätulo (float-skalaari). 2-ulotteisille taulukoille tämä on matriisikertolasku; sisäulottuvuuksien on täsmättävä. Tulos on aina dtype-tyyppiä float.

Approksimointi¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Yksiulotteinen lineaarinen interpolointi. xp:n on oltava monotonisesti kasvava 1-ulotteinen riippumattomien arvojen taulukko; fp sisältää vastaavat riippuvat arvot; x ovat pisteet, joissa interpolantti lasketaan. left ja right korvaavat arvot, jotka palautetaan tapauksissa x < xp[0] ja x > xp[-1] (oletukset: fp[0] ja fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integroi y käyttäen yhdistettyä puolisuunnikassääntöä. Jos x annetaan, se määrittää y:tä vastaavat näytepositiot; muutoin käytetään väliä dx. y:n (ja x:n) on oltava 1-ulotteisia.

Valinta¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Ota a-taulukosta alkiot annetuissa indekseissä indices axis-akselia pitkin. Arvolla axis=None käytetään litistettyä taulukkoa. mode valitsee rajat ylittävän käyttäytymisen: "raise" (oletus – nostaa ValueError), "wrap" (modulo akselin pituus) tai "clip" (leikkaa sallitulle alueelle; negatiivisia indeksejä ei sallita). Jos out annetaan, tulos kirjoitetaan siihen.

Bittikohtaiset¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: Kahden kokonaislukutaulukon alkioittainen bittikohtainen JA; lähetys (broadcast) on tuettu. Ei-kokonaislukutyyppinen dtype nostaa poikkeuksen.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: Kahden kokonaislukutaulukon alkioittainen bittikohtainen TAI.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: Kahden kokonaislukutaulukon alkioittainen bittikohtainen XTAI.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Alkioittainen x1-taulukon bittikohtainen siirto vasemmalle x2 bittiä; molemmilla taulukoilla on oltava kokonaislukutyyppinen dtype.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Alkioittainen x1-taulukon bittikohtainen siirto oikealle x2 bittiä; molemmilla taulukoilla on oltava kokonaislukutyyppinen dtype.

Suodatus¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Palauta kahden 1-ulotteisen taulukon diskreetti lineaarinen konvoluutio. Vain "full"-tila on tuettu; numpyn mode-avainsanaa ei hyväksytä (muut tilat voidaan saada viipaloimalla täysi tulos). Tuloksen pituus on len(a) + len(v) - 1.

Polynomi¶

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Sovita asteen deg polynomi datapisteisiin (x, y) pienimmän neliösumman menetelmällä ja palauta polynomin kertoimet (korkein aste ensin). Jos x jätetään pois, käytetään range(len(y)). Nostaa ValueError-poikkeuksen, jos x:n ja y:n pituudet eroavat.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Laske polynomi, jonka kertoimet ovat p (korkein aste ensin), pisteessä x. Jos x on skalaari, palautetaan float, muutoin ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Lue aiemmin funktiolla save kirjoitettu taulukko tiedostosta file (numpyn alustariippumaton .npy-muoto). Endiaanisuus muunnetaan lennossa, jos tiedoston tavujärjestys eroaa isäntäkoneen omasta.

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¶: Lue numeerista dataa tekstitiedostosta file ja palauta se ndarray-taulukkona. delimiter on oletuksena tyhjätila; comments on rivikommenttimerkki; max_rows rajoittaa luettavien datarivien määrää (-1 kaikille); usecols valitsee sarakkeet indeksin perusteella; skiprows ohittaa kyseisen määrän alkurivejä. Jos dtype ei ole float, arvot muunnetaan pyöristämällä.

numpy.save(file: str, a: ndarray) → None¶: Tallenna a tiedostoon file numpyn alustariippumattomassa .npy-muodossa.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Kirjoita a tiedostoon file tekstinä. delimiter erottaa arvot rivin sisällä; header ja footer, jos annettu, kirjoitetaan ennen dataa / sen jälkeen, kumpikin etuliitteenään comments. Arvot kirjoitetaan liukulukuina.

Kompleksilukuapurit¶

Nämä funktiot ovat käytettävissä vain kun ulab on käännetty kompleksilukutuella (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Palauta val-arvon reaaliosa. Reaalityyppiselle syötteelle palauttaa kopion säilyttäen dtype-tyypin; kompleksiselle syötteelle palauttaa float-ndarray-taulukon.

numpy.imag(val: ndarray) → ndarray¶: Palauta val-arvon imaginaariosa. Reaalityyppiselle syötteelle palauttaa nollien taulukon samalla dtype-tyypillä; kompleksiselle syötteelle palauttaa float-ndarray-taulukon.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Palauta val-arvon kompleksikonjugaatti. Reaaliarvoiset syötteet palautetaan muuttumattomina.

numpy.sort_complex(a: ndarray) → ndarray¶: Lajittele 1-ulotteinen taulukko a ensin reaaliosan ja sitten imaginaariosan mukaan. Tulos on aina kompleksista dtype-tyyppiä, vaikka a olisi reaaliarvoinen.

Universaalit funktiot¶

Alkioittaiset matematiikkafunktiot. Kukin hyväksyy skalaarin tai ndarray-taulukon ja palauttaa muodoltaan vastaavan tuloksen (float-skalaarin skalaarisyötteelle, ndarray-taulukon taulukkosyötteelle). Kutsuttaessa ndarray-taulukolla tulos on uusi liukuluku-ndarray-taulukko; valinnainen out-avainsana voidaan välittää tuloksen kirjoittamiseksi esivarattuun samankokoiseen float-ndarray-taulukkoon.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion käänteiskosini (arkuskosini); tulos on radiaaneina.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion käänteishyperbolinen kosini.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Laske kaksiargumenttinen käänteistangentti atan2(y, x) alkioittain; tukee lähetystä (broadcast) kahden syötteen välillä.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Pyöristä ndarray-taulukon x alkiot annettuun määrään desimaaleja decimals; ensimmäisen argumentin on oltava ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion käänteissini (arkussini); tulos on radiaaneina.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion käänteishyperbolinen sini.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion käänteistangentti (arkustangentti); tulos on radiaaneina.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion käänteishyperbolinen tangentti.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion kattofunktio (pienin kokonaisluku, joka ei ole arvoa pienempi).

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion kosini (radiaaneina).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion hyperbolinen kosini.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Muunna x-taulukon kukin alkio radiaaneista asteiksi.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion eksponentti e**x; voi palauttaa kompleksisen ndarray-taulukon kompleksisyötteellä (jos kompleksilukutuki on käytössä).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion exp(x) - 1 parannetulla tarkkuudella lähellä nollaa.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion lattiafunktio (suurin kokonaisluku, joka ei ole arvoa suurempi).

numpy.log(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion luonnollinen logaritmi.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion 10-kantainen logaritmi.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion 2-kantainen logaritmi.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Muunna x-taulukon kukin alkio asteista radiaaneiksi.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion sini (radiaaneina).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion normalisoitu sinc-funktio sin(pi*x) / (pi*x).

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion hyperbolinen sini.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Laske x-taulukon kunkin alkion neliöjuuri; välitä dtype=numpy.complex saadaksesi kompleksisia tuloksia negatiivisille reaalisyötteille (jos kompleksilukutuki on käytössä).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion tangentti (radiaaneina).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Laske x-taulukon kunkin alkion hyperbolinen tangentti.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Palauta kutsuttava objekti, joka soveltaa Python-funktiota f alkioittain skalaariin, iteroitavaan tai ndarray-taulukkoon; otypes valitsee tulosteen dtype-tyypin (oletuksena float).

Vakiot¶

numpy.e: float¶: Eulerin luku \(e \approx 2.71828\).

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

numpy.inf: float¶: IEEE-754-liukuluvun positiivinen ääretön.

numpy.nan: float¶: IEEE-754-liukuluvun ”ei luku” (not a number).

numpy.bool: int¶: Dtype-koodi totuusarvoisille taulukoille (tallennetaan uint8-tyyppinä).

numpy.uint8: int¶: Dtype-koodi etumerkittömille 8-bittisille kokonaislukutaulukoille.

numpy.int8: int¶: Dtype-koodi etumerkillisille 8-bittisille kokonaislukutaulukoille.

numpy.uint16: int¶: Dtype-koodi etumerkittömille 16-bittisille kokonaislukutaulukoille.

numpy.int16: int¶: Dtype-koodi etumerkillisille 16-bittisille kokonaislukutaulukoille.

numpy.float: int¶: Dtype-koodi 32-bittisille liukulukutaulukoille.

numpy — numpy-yhteensopivat taulukko-operaatiot¶