`numpy` — numpy-compatibele arraybewerkingen¶

De numpy-submodule van ulab biedt een numpy-compatibele API die is opgebouwd rond het n-dimensionale arraytype ndarray. Het implementeert een zorgvuldig samengestelde subset van CPython numpy: arrayconstructie, elementgewijze wiskunde, reducties en statistieken, lineaire algebra, FFT’s, generatie van willekeurige getallen, polynoomfitting en eenvoudige I/O.

De submodule wordt conventioneel geïmporteerd als 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)))

Elk dtype-argument is een van de gehele-getalconstanten die op moduleniveau beschikbaar zijn: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (de standaard) en (wanneer complexe ondersteuning is meegecompileerd) numpy.complex. Het resultaattype ndarray verwijst naar numpy.ndarray.

Submodules¶

klasse `ndarray` — de n-dimensionale array¶

De ndarray is de n-dimensionale, dtype-bewuste container die de kern vormt van numpy / ulab. De gegevens worden opgeslagen in een aaneengesloten blok waarvan de interpretatie wordt beschreven door een kleine header (dtype, shape, strides, ndim, itemsize). Veel bewerkingen – reshape, transpose, slicing – passen alleen deze header aan en zijn daarom zeer goedkoop; methoden die nieuwe opslag toewijzen (copy, flatten, de meeste rekenkundige bewerkingen) retourneren een nieuwe dichte array.

Hetzelfde type is bereikbaar als ulab.ndarray, numpy.ndarray en (binnen deze pagina) simpelweg ndarray.

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

Maak een nieuwe ndarray.

Parameters:

values – Brongegevens. Ofwel een andere ndarray (die diep wordt gekopieerd, met typeconversie als dtype verschilt) of een willekeurige MicroPython-iterable. Geneste iterables produceren multidimensionale arrays; de binnenste iterables moeten allemaal dezelfde lengte hebben, anders wordt een ValueError opgeworpen.
dtype – Het elementtype voor de nieuwe array. Een van de typecode-gehele getallen die door numpy beschikbaar worden gesteld (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float en – indien ondersteund – numpy.complex), of een dtype-instantie. De standaardwaarde is numpy.float.

De fabrieksfunctie numpy.array is de conventionele manier om een ndarray te maken; deze stuurt door naar deze constructor.

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

Wissel de bytevolgorde van elk element om. Voor uint16-, int16-, float- en complex-arrays keert dit de bytevolgorde per element om, wat nuttig is bij het verwerken van gegevens van randapparaten waarvan de endianness niet overeenkomt met die van de microcontroller. Voor dtypes van één byte (bool, uint8, int8) is dit een no-op die een view of kopie retourneert.

Als inplace False is (de standaard) wordt een nieuwe ndarray geretourneerd en blijft het origineel ongewijzigd. Als inplace True is, worden de bytes van self ter plaatse omgewisseld en wordt een view van self geretourneerd.

copy() → ndarray¶: Retourneer een nieuwe dichte, diepe kopie van de array. De kopie bezit zijn eigen gegevens; wijzigingen eraan hebben geen invloed op het origineel.

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

Retourneer een nieuwe eendimensionale kopie van de array.

Parameters:: order – 'C' (de standaard) doorloopt de gegevens in C-volgorde (de laatste as varieert het snelst); 'F' doorloopt ze in Fortran-volgorde (de eerste as varieert het snelst).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Retourneer een view van de array met een nieuwe vorm. Het totale aantal elementen moet ongewijzigd blijven, anders wordt een ValueError opgeworpen. Alleen beschikbaar wanneer ULAB_MAX_DIMS > 1. Equivalent aan toewijzen aan shape.

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

Sorteer de array ter plaatse.

Parameters:: axis – De as waarlangs wordt gesorteerd. -1 (de standaard) sorteert langs de laatste as; None maakt de array eerst plat en sorteert dan.

tobytes() → bytearray¶: Retourneer een bytearray die de onderliggende gegevensbuffer van de array aliasseert. Schrijfacties via de geretourneerde bytearray wijzigen de array ter plaatse. Werpt ValueError op als de array niet dicht is (bijv. een gesliced view).

tolist() → list¶: Retourneer de inhoud van de array als een (mogelijk geneste) Python-list. De nestingdiepte is gelijk aan ndim.

transpose() → ndarray¶: Retourneer de getransponeerde van de array (assen omgekeerd). Voor eendimensionale arrays retourneert dit self. Alleen beschikbaar wanneer ULAB_MAX_DIMS > 1. Het attribuut T is een afkorting voor deze methode.

dtype: dtype | int¶: Het gegevenstype van de elementen van de array. Retourneert een dtype-instantie wanneer de firmware is gebouwd met ULAB_HAS_DTYPE_OBJECT ingeschakeld, anders de onderliggende typecode van één teken als geheel getal.

flat: flatiter¶: Een platte iterator die elk element van de array in C-volgorde oplevert. In tegenstelling tot flatten() wijst het itereren over flat geen nieuwe array toe.

itemsize: int¶: Grootte in bytes van een enkel arrayelement, afgeleid van dtype.

ndim: int¶: Aantal arraydimensies (lengte van shape).

shape: tuple[int, ...]¶: Lengtes van de array langs elke as. Het toewijzen van een tuple aan shape verandert de vorm van de array ter plaatse (equivalent aan reshape()).

size: int¶: Totaal aantal elementen in de array (het product van shape).

strides: tuple[int, ...]¶: Aantal bytes dat in het geheugen langs elke as moet worden gestapt om het volgende element langs die as te bereiken.

T: ndarray¶: De getransponeerde van de array; equivalent aan transpose().

real: ndarray¶: Het reële deel van een complexe array, geretourneerd als een float-ndarray. Voor reële arrays is dit een kopie van self met hetzelfde dtype. Alleen beschikbaar wanneer de firmware is gebouwd met complexe ondersteuning.

imag: ndarray¶: Het imaginaire deel van een complexe array, geretourneerd als een float-ndarray. Voor reële arrays is dit een array van nullen met hetzelfde dtype als self. Alleen beschikbaar wanneer de firmware is gebouwd met complexe ondersteuning.

Ondersteunde operatoren¶

ndarray-instanties ondersteunen de volgende operatoren. Binaire operatoren broadcasten hun operanden volgens de standaard numpy-broadcastingregels en volgen numpy’s upcastingregels (bijv. uint8 + int8 => int16, uint16 + int16 => float); bewerkingen waarbij een complexe operand betrokken is, produceren een complex resultaat.

Rekenkundig (binair): +, -, *, /, //, %, **. Gereflecteerde (rechterhand) operanden en de in-place varianten +=, -=, *=, /=, %=, **= worden eveneens ondersteund. Zowel de ndarray-met-ndarray- als de ndarray-met-scalair-vormen worden geaccepteerd. Gehele deling (//) en de modulo-operator (%) zijn niet geïmplementeerd voor complex-arrays.

Vergelijking: ==, !=, <, <=, >, >=. Elk retourneert een booleaanse ndarray met de broadcast-vorm.

Bitsgewijs (alleen gehele-getalarrays): &, |, ^. Het toepassen hiervan op een float- of complex-array werpt TypeError op.

Unair: + (retourneert een kopie), - (negatie; bij niet-ondertekende dtypes wikkelen de waarden modulo \(2^N\)), abs() (elementgewijze absolute waarde; bij niet-ondertekende dtypes retourneert een kopie zonder berekening), ~ (bitsgewijze inversie, alleen gehele-getaldtypes), len() (retourneert de lengte van de eerste as).

Indexeren en slicen: a[i], a[i, j, ...], a[start:stop:step], indexering met booleaanse maskers (a[mask]) en indexering met gehele-getalarrays (fancy indexing) worden alle ondersteund bij zowel lezen als schrijven.

Iteratie: Het itereren over een ndarray levert subarrays op langs de eerste as (één element per keer voor 1D-arrays). Gebruik flat om over elk scalair element te itereren, ongeacht de dimensionaliteit.

De matrixvermenigvuldigingsoperator @ is niet geïmplementeerd; gebruik in plaats daarvan numpy.dot (np.dot(a, b)).

De shift-operatoren (<<, >>) zijn niet geïmplementeerd op operatorniveau. Gebruik numpy.left_shift en numpy.right_shift voor elementgewijze gehele-getalshifts.

Arrayconstructie¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Construeer een nieuwe ndarray uit een geneste iterable van getallen. Equivalente alternatieve constructor voor numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Retourneer gelijkmatig verdeelde waarden over het half-open interval [start, stop). Als er slechts één positioneel argument wordt opgegeven, wordt dit behandeld als stop met start = 0. Als dtype wordt weggelaten, wordt het afgeleid uit de invoer (geheel getal als start, stop en step allemaal gehele getallen zijn en binnen het bereik vallen).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Als a al een ndarray is waarvan het dtype overeenkomt met dtype (of dtype is None), retourneer a ongewijzigd; maak anders een nieuwe array (met de gevraagde dtype-conversie indien opgegeven). Iterables worden geconverteerd zoals in numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Voeg een reeks ndarray samen langs een bestaande axis. Alle invoerarrays moeten hetzelfde dtype, dezelfde ndim en dezelfde vorm delen op elke as behalve axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Voor een 2D-a, retourneer een 1D-array die de k-de diagonaal bevat. Voor een 1D-a, retourneer een 2D-vierkante array met a geplaatst op de k-de diagonaal. k mag positief (boven de hoofddiagonaal) of negatief (eronder) zijn.

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Alias voor zeros; retourneert een met nullen gevulde array van shape en dtype. (ulab laat de buffer niet ongeïnitialiseerd.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Retourneer een 2D-N x M-array (vierkant N x N als M None is) met enen op de k-de diagonaal en nullen elders.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Interpreteer een object dat het bufferprotocol implementeert als een 1D-ndarray van dtype. count is het aantal te lezen items (-1 leest alle beschikbare items); offset slaat dat aantal bytes aan het begin van de buffer over.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Retourneer een nieuwe array van shape en dtype waarbij elk element is ingesteld op fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Retourneer num gelijkmatig verdeelde samples over het gesloten interval [start, stop] (of half-open als endpoint False is). Wanneer retstep True is, retourneer een tuple (samples, step). Complexe start/stop produceren een complexe array (wanneer complexe ondersteuning is ingeschakeld).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Retourneer num samples gelijkmatig verdeeld op een logaritmische schaal: het resultaat begint bij base ** start en eindigt bij base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Retourneer een tuple van coördinaatmatrices uit een reeks eendimensionale coördinaatarrays. Met indexing 'xy' (de standaard) worden de eerste twee invoeren behandeld als cartesische coördinaten en worden hun uitvoerassen verwisseld; met 'ij' wordt indexering in matrixstijl gebruikt. De implementatie komt overeen met het NumPy-equivalent met copy=True en sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Retourneer een nieuwe array van shape en dtype gevuld met enen.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Retourneer een nieuwe array van shape en dtype gevuld met nullen.

Inspectie / afdrukken¶

numpy.get_printoptions() → dict¶: Retourneer de huidige opties voor het afdrukken van arrays als een dict met de sleutels threshold en edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Stel de opties voor het afdrukken van arrays in. threshold is het maximale aantal arrayelementen dat volledig wordt afgedrukt; edgeitems is het aantal items dat aan elk uiteinde van een as wordt getoond wanneer de array wordt samengevat.

numpy.ndinfo(array: ndarray) → None¶: Druk diagnostische informatie (shape, strides, dtype, itemsize, …) over array af.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Retourneer het aantal elementen van a langs axis; als axis None is, retourneer het totale aantal elementen (het product van ndarray.shape).

Vergelijking¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Begrens de waarden van a zodat a_min <= result <= a_max. Equivalent aan maximum(a_min, minimum(a, a_max)); broadcasting volgt dezelfde regels als minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Elementgewijze x1 == x2; retourneert een booleaanse ndarray (of een bool-scalair als beide invoeren scalairen zijn). Geboden voor portabiliteit – de operator == op arrays geeft hetzelfde resultaat.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: Elementgewijze x1 != x2; de booleaanse tegenhanger van equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Retourneer een booleaanse array (of scalair) die True is waar de invoer eindig is. Gehele-getalinvoer is altijd eindig.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Retourneer een booleaanse array (of scalair) die True is waar de invoer oneindig is. Gehele-getalinvoer is nooit oneindig.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Elementgewijze maximum van twee arrays / scalairen. De argumenten worden samen gebroadcast; als de dtypes verschillen, wordt de uitvoer geüpcast.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Elementgewijze minimum van twee arrays / scalairen; tegenhanger van maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Retourneer een tuple van ndarray, één per dimensie van a, die de indices van de niet-nul-elementen van a bevat.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Retourneer een ndarray waarvan de elementen afkomstig zijn van x waar condition waarheidsgetrouw is, en anders van y. De drie invoeren worden samen gebroadcast; het uitvoer-dtype is de upcast van x en y.

Numerieke reducties¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Test of alle elementen langs axis tot True evalueren. Met axis=None (de standaard) wordt de platgemaakte array getest en wordt een enkele bool geretourneerd.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Test of een willekeurig element langs axis tot True evalueert. Met axis=None wordt de platgemaakte array getest.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Retourneer de index van het maximale element langs axis. Met axis=None wordt de array platgemaakt en wordt een enkel geheel getal geretourneerd.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Retourneer de index van het minimale element langs axis. Met axis=None wordt de array platgemaakt en wordt een enkel geheel getal geretourneerd.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Retourneer een niet-ondertekende gehele-getalindex-ndarray waarvan de elementen a in oplopende volgorde sorteren langs axis. Het uitvoer-dtype is uint16, dus geen enkele as mag meer dan 65535 elementen bevatten. axis=None wordt niet ondersteund.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Retourneer het uitwendig product van twee 1D-arrays van lengte 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Retourneer het n-de discrete voorwaartse verschil van a langs axis. n moet in 0..9 liggen (de differentiatiestencil wordt opgeslagen in een int8); de lengte van axis krimpt met n. De numpy-sleutelwoorden prepend en append zijn niet geïmplementeerd.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Retourneer een nieuwe array met de volgorde van de elementen omgekeerd langs axis; met axis=None wordt de array langs elke as omgekeerd.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Retourneer het maximale element langs axis. Met axis=None (de standaard) wordt de platgemaakte array gereduceerd tot een scalair. Het numpy-sleutelwoord out is niet geïmplementeerd.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Retourneer het minimale element langs axis; tegenhanger van max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Retourneer het rekenkundig gemiddelde langs axis. Met axis=None (de standaard) wordt het gemiddelde van de platgemaakte array geretourneerd als een float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Retourneer de mediaan langs axis. Met axis=None wordt de array eerst platgemaakt. Het uitvoer-dtype is altijd float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Retourneer a met de elementen gerold (cyclisch verschoven) met shift posities. Met axis=None (de standaard) wordt de array eerst platgemaakt. Negatieve shifts rollen in de tegengestelde richting.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Retourneer een gesorteerde kopie van a langs axis met behulp van heap sort. Met axis=None wordt de array eerst platgemaakt. De numpy-sleutelwoorden kind en order zijn niet geïmplementeerd.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Retourneer de standaardafwijking langs axis. ddof is de delta degrees of freedom – de gebruikte deler is N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Retourneer de som langs axis. Met axis=None wordt het totaal van de platgemaakte array geretourneerd als een scalair.

Statistieken¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Tel het aantal keren dat elke waarde voorkomt in de eendimensionale, niet-negatieve gehele-getalarray x. Het dtype van x moet uint8 of uint16 zijn. Als weights wordt opgegeven, draagt elk element van x zijn bijbehorende gewicht bij in plaats van 1 en is de uitvoer van dtype float; anders is de uitvoer van dtype uint16. Als minlength wordt opgegeven, heeft de uitvoerarray ten minste dat aantal elementen (extra elementen zijn nul).

numpy.trace(m: ndarray) → int | float¶: Retourneer de som van de diagonale elementen van de vierkante matrix m. Het retourtype volgt het dtype van m (gehele-getalarrays produceren een int, float-arrays een float).

Transform¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Retourneer slices van a geselecteerd langs axis door de booleaanse condition. Met axis=None wordt de platgemaakte array gebruikt.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Retourneer een kopie van a waarbij de elementen op indices zijn verwijderd langs axis. Met axis=None wordt de array eerst platgemaakt. Negatieve indices tellen vanaf het einde van axis; indices wordt intern gesorteerd vóór verwijdering.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Retourneer het inwendig product van twee arrays. Voor twee 1D-arrays is dit het inproduct (een float-scalair). Voor 2D-arrays is dit matrixvermenigvuldiging; de binnenste dimensies moeten overeenkomen. Het resultaat is altijd van dtype float.

Benadering¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Eendimensionale lineaire interpolatie. xp moet een monotoon stijgende 1D-array van onafhankelijke waarden zijn; fp bevat de bijbehorende afhankelijke waarden; x zijn de punten waarop de interpolant wordt geëvalueerd. left en right overschrijven respectievelijk de waarde die wordt geretourneerd voor x < xp[0] en x > xp[-1] (standaardwaarden: fp[0] en fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integreer y met behulp van de samengestelde trapeziumregel. Als x wordt opgegeven, levert dit de samplepositiess die overeenkomen met y; anders wordt de afstand dx gebruikt. y (en x) moeten 1D zijn.

Selectie¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Neem elementen uit a op de gegeven indices langs axis. Met axis=None wordt de platgemaakte array gebruikt. mode selecteert het gedrag buiten het bereik: "raise" (standaard – werpt ValueError op), "wrap" (modulo de aslengte), of "clip" (begrenzen tot het geldige bereik; negatieve indices zijn niet toegestaan). Als out wordt opgegeven, wordt het resultaat daarin geschreven.

Bitsgewijs¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: Elementgewijze bitsgewijze AND van twee gehele-getalarrays; broadcasting wordt ondersteund. Een niet-gehele dtype werpt een uitzondering op.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: Elementgewijze bitsgewijze OR van twee gehele-getalarrays.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: Elementgewijze bitsgewijze XOR van twee gehele-getalarrays.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Elementgewijze bitsgewijze verschuiving van x1 naar links met x2 bits; beide arrays moeten een gehele-getaldtype hebben.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Elementgewijze bitsgewijze verschuiving van x1 naar rechts met x2 bits; beide arrays moeten een gehele-getaldtype hebben.

Filteren¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Retourneer de discrete lineaire convolutie van twee 1D-arrays. Alleen de modus "full" wordt ondersteund; het numpy-sleutelwoord mode wordt niet geaccepteerd (andere modi kunnen worden verkregen door het volledige resultaat te slicen). De uitvoerlengte is len(a) + len(v) - 1.

Polynoom¶

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Fit een polynoom van graad deg aan de datapunten (x, y) via kleinste kwadraten en retourneer de polynoomcoëfficiënten (hoogste graad eerst). Als x wordt weggelaten, wordt range(len(y)) gebruikt. Werpt ValueError op als de lengtes van x en y verschillen.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Evalueer de polynoom waarvan de coëfficiënten p zijn (hoogste graad eerst) bij x. Als x een scalair is, wordt een float geretourneerd, anders een ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Lees een array die eerder met save is weggeschreven uit file (numpy’s platformonafhankelijke .npy-formaat). De endianness wordt onderweg geconverteerd als de bytevolgorde van het bestand verschilt van die van de host.

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¶: Lees numerieke gegevens uit een tekst-file en retourneer ze als een ndarray. delimiter is standaard witruimte; comments is de markering voor regelcommentaar; max_rows beperkt het aantal gelezen datarijen (-1 voor alle); usecols selecteert kolommen op index; skiprows slaat dat aantal voorloopregels over. Als dtype niet float is, worden de waarden geconverteerd door afronding.

numpy.save(file: str, a: ndarray) → None¶: Sla a op in file in numpy’s platformonafhankelijke .npy-formaat.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Schrijf a als tekst naar file. delimiter scheidt de waarden binnen een rij; header en footer, indien opgegeven, worden vóór/na de gegevens geschreven, elk voorafgegaan door comments. Waarden worden als drijvende komma geschreven.

Complexe hulpfuncties¶

Deze functies zijn alleen beschikbaar wanneer ulab is gecompileerd met complexe ondersteuning (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Retourneer het reële deel van val. Voor een invoer met reëel dtype retourneert dit een kopie met behoud van het dtype; voor een complexe invoer retourneert dit een float-ndarray.

numpy.imag(val: ndarray) → ndarray¶: Retourneer het imaginaire deel van val. Voor een invoer met reëel dtype retourneert dit een array van nullen met hetzelfde dtype; voor een complexe invoer retourneert dit een float-ndarray.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Retourneer de complex geconjugeerde van val. Reëelwaardige invoer wordt ongewijzigd geretourneerd.

numpy.sort_complex(a: ndarray) → ndarray¶: Sorteer de 1D-array a eerst op reëel deel, daarna op imaginair deel. Het resultaat is altijd van complex dtype, ook als a reëelwaardig was.

Universele functies¶

Elementgewijze wiskundige functies. Elk accepteert een scalair of een ndarray en retourneert een resultaat met overeenkomende vorm (een float-scalair voor scalaire invoer, een ndarray voor arrayinvoer). Wanneer aangeroepen met een ndarray, is het resultaat een nieuwe drijvende-komma-ndarray; een optioneel out-sleutelwoord mag worden meegegeven om het resultaat te schrijven naar een vooraf toegewezen float-ndarray van dezelfde grootte.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Bereken de inverse cosinus (boogcosinus) van elk element van x; het resultaat is in radialen.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Bereken de inverse hyperbolische cosinus van elk element van x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Bereken de inverse tangens met twee argumenten atan2(y, x) elementgewijs; ondersteunt broadcasting tussen de twee invoeren.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Rond de elementen van de ndarray x af op het gegeven aantal decimals; het eerste argument moet een ndarray zijn.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Bereken de inverse sinus (boogsinus) van elk element van x; het resultaat is in radialen.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Bereken de inverse hyperbolische sinus van elk element van x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Bereken de inverse tangens (boogtangens) van elk element van x; het resultaat is in radialen.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Bereken de inverse hyperbolische tangens van elk element van x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Bereken het plafond (kleinste geheel getal niet kleiner dan de waarde) van elk element van x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Bereken de cosinus van elk element van x (in radialen).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Bereken de hyperbolische cosinus van elk element van x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Converteer elk element van x van radialen naar graden.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Bereken de exponentiële e**x van elk element van x; kan een complexe ndarray retourneren bij complexe invoer (als complexe ondersteuning is ingeschakeld).

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Bereken exp(x) - 1 van elk element van x met verbeterde precisie nabij nul.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Bereken de vloer (grootste geheel getal niet groter dan de waarde) van elk element van x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: Bereken de natuurlijke logaritme van elk element van x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Bereken de logaritme met grondtal 10 van elk element van x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Bereken de logaritme met grondtal 2 van elk element van x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Converteer elk element van x van graden naar radialen.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Bereken de sinus van elk element van x (in radialen).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Bereken de genormaliseerde sinc-functie sin(pi*x) / (pi*x) van elk element van x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Bereken de hyperbolische sinus van elk element van x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Bereken de vierkantswortel van elk element van x; geef dtype=numpy.complex mee om complexe resultaten te verkrijgen voor negatieve reële invoer (als complexe ondersteuning is ingeschakeld).

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Bereken de tangens van elk element van x (in radialen).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Bereken de hyperbolische tangens van elk element van x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Retourneer een aanroepbaar object dat de Python-functie f elementgewijs toepast op een scalair, iterable of ndarray; otypes selecteert het uitvoer-dtype (standaard float).

Constanten¶

numpy.e: float¶: Het getal van Euler \(e \approx 2.71828\).

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

numpy.inf: float¶: IEEE-754 drijvende-komma positieve oneindigheid.

numpy.nan: float¶: IEEE-754 drijvende-komma “not a number”.

numpy.bool: int¶: Dtype-code voor booleaanse arrays (opgeslagen als uint8).

numpy.uint8: int¶: Dtype-code voor niet-ondertekende 8-bits gehele-getalarrays.

numpy.int8: int¶: Dtype-code voor ondertekende 8-bits gehele-getalarrays.

numpy.uint16: int¶: Dtype-code voor niet-ondertekende 16-bits gehele-getalarrays.

numpy.int16: int¶: Dtype-code voor ondertekende 16-bits gehele-getalarrays.

numpy.float: int¶: Dtype-code voor 32-bits drijvende-komma-arrays.

numpy — numpy-compatibele arraybewerkingen¶