`numpy` — operações em arrays compatíveis com numpy¶

O submódulo numpy do ulab fornece uma API compatível com numpy construída em torno do tipo de array n-dimensional ndarray. Implementa um subconjunto selecionado do numpy do CPython: construção de arrays, operações matemáticas elemento a elemento, reduções e estatísticas, álgebra linear, FFTs, geração de números aleatórios, ajuste polinomial e I/O básico.

O submódulo é convencionalmente importado como 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)))

Each dtype argument is one of the integer constants exposed at module level: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, and numpy.float (the default). The result type ndarray refers to numpy.ndarray.

Submódulos¶

class `ndarray` — o array n-dimensional¶

O ndarray é o contentor n-dimensional com suporte a dtype no núcleo do numpy / ulab. Os dados são armazenados num bloco contíguo cuja interpretação é descrita por um pequeno cabeçalho (dtype, shape, strides, ndim, itemsize). Muitas operações – reshape, transpose, slicing – apenas ajustam este cabeçalho e são, por isso, muito eficientes; métodos que alocam novo armazenamento (copy, flatten, a maioria das operações aritméticas) devolvem um novo array denso.

O mesmo tipo é acessível como ulab.ndarray, numpy.ndarray, e (nesta página) simplesmente ndarray.

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

Criar um novo ndarray.

Parâmetros:

values – Dados de origem. Pode ser outro ndarray (que é copiado profundamente, com conversão de tipo se dtype for diferente) ou qualquer iterável do MicroPython. Iteráveis aninhados produzem arrays multidimensionais; os iteráveis internos devem ter todos o mesmo comprimento ou é gerado um ValueError.
dtype – Element type for the new array. One of the type-code integers exposed by numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, and numpy.float), or a dtype instance. Defaults to numpy.float.

A função de fábrica numpy.array é a forma convencional de criar um ndarray; delega para este construtor.

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

Swap the byte order of every element. For uint16, int16, and float arrays this reverses the per-element byte order, which is useful when consuming data from peripherals whose endianness does not match the microcontroller’s. For single-byte dtypes (bool, uint8, int8) this is a no-op that returns a view or copy.

Se inplace for False (o padrão), é devolvido um novo ndarray e o original fica intacto. Se inplace for True, os bytes de self são trocados no local e é devolvida uma vista de self.

copy() → ndarray¶: Devolve uma nova cópia profunda e densa do array. A cópia é dona dos seus próprios dados; as modificações sobre ela não afetam o original.

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

Devolve uma nova cópia unidimensional do array.

Parâmetros:: order – 'C' (o padrão) percorre os dados em ordem C (o último eixo varia mais rapidamente); 'F' percorre-os em ordem Fortran (o primeiro eixo varia mais rapidamente).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Devolve uma vista do array com uma nova forma. O número total de elementos deve permanecer inalterado, caso contrário é gerado um ValueError. Disponível apenas quando ULAB_MAX_DIMS > 1. Equivalente a atribuir a shape.

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

Ordena o array no local.

Parâmetros:: axis – Eixo ao longo do qual ordenar. -1 (o padrão) ordena ao longo do último eixo; None achata primeiro o array e depois ordena.

tobytes() → bytearray¶: Devolve um bytearray que é um alias do buffer de dados subjacente do array. As escritas através do bytearray devolvido modificam o array no local. Gera ValueError se o array não for denso (por exemplo, uma vista fatiada).

tolist() → list¶: Devolve o conteúdo do array como uma list Python (possivelmente aninhada). A profundidade de aninhamento é igual a ndim.

transpose() → ndarray¶: Devolve a transposta do array (eixos invertidos). Para arrays unidimensionais, devolve self. Disponível apenas quando ULAB_MAX_DIMS > 1. O atributo T é uma abreviatura para este método.

dtype: dtype | int¶: O tipo de dados dos elementos do array. Devolve uma instância de dtype quando o firmware é compilado com ULAB_HAS_DTYPE_OBJECT ativo, caso contrário devolve o código de tipo de caractere único subjacente como inteiro.

flat: flatiter¶: Um iterador plano que produz cada elemento do array em ordem C. Ao contrário de flatten(), iterar flat não aloca um novo array.

itemsize: int¶: Tamanho em bytes de um único elemento do array, derivado de dtype.

ndim: int¶: Número de dimensões do array (comprimento de shape).

shape: tuple[int, ...]¶: Comprimentos do array ao longo de cada eixo. Atribuir um tuplo a shape redimensiona o array no local (equivalente a reshape()).

size: int¶: Número total de elementos no array (o produto de shape).

strides: tuple[int, ...]¶: Número de bytes a percorrer em memória ao longo de cada eixo para alcançar o elemento seguinte nesse eixo.

T: ndarray¶: A transposta do array; equivalente a transpose().

Operadores suportados¶

ndarray instances support the following operators. Binary operators broadcast their operands following standard numpy broadcasting rules and follow numpy’s upcasting rules (e.g. uint8 + int8 => int16, uint16 + int16 => float).

Arithmetic (binary): +, -, *, /, //, %, **. Reflected (right-hand) operands and the in-place variants +=, -=, *=, /=, %=, **= are also supported. Both ndarray-with-ndarray and ndarray-with-scalar forms are accepted.

Comparação: ==, !=, <, <=, >, >=. Cada um devolve um ndarray booleano da forma difundida.

Bitwise (integer arrays only): &, |, ^. Applying these to a float array raises TypeError.

Unários: + (devolve uma cópia), - (negação; em dtypes sem sinal os valores envolvem modulo \(2^N\)), abs() (valor absoluto elemento a elemento; em dtypes sem sinal devolve uma cópia sem cálculo), ~ (inversão bit a bit, apenas dtypes inteiros), len() (devolve o comprimento do primeiro eixo).

Indexação e fatiamento: a[i], a[i, j, ...], a[start:stop:step], indexação por máscara booleana (a[mask]) e indexação por array inteiro (fancy indexing) são todos suportados tanto em leituras como em escritas.

Iteração: Iterar sobre um ndarray produz sub-arrays ao longo do primeiro eixo (um elemento de cada vez para arrays 1-D). Use flat para iterar sobre cada elemento escalar independentemente da dimensionalidade.

O operador de multiplicação de matrizes @ não está implementado; use numpy.dot (np.dot(a, b)) em alternativa.

Os operadores de deslocamento (<<, >>) não estão implementados ao nível do operador. Use numpy.left_shift e numpy.right_shift para deslocamentos inteiros elemento a elemento.

Construção de arrays¶

numpy.array(values: ndarray | list | tuple, *, dtype: int = float) → ndarray¶: Constrói um novo ndarray a partir de um iterável aninhado de números. Construtor alternativo equivalente para numpy.ndarray.

numpy.arange(start: int | float, stop: int | float | None = None, step: int | float = 1, *, dtype: int | None = None) → ndarray¶: Devolve valores igualmente espaçados no intervalo semi-aberto [start, stop). Se apenas um argumento posicional for fornecido, é tratado como stop com start = 0. Se dtype for omitido, é inferido a partir das entradas (inteiro se start, stop, step forem todos inteiros e estiverem dentro do intervalo).

numpy.asarray(a: ndarray | list | tuple, *, dtype: int | None = None) → ndarray¶: Se a já for um ndarray cujo dtype corresponde a dtype (ou dtype for None), devolve a sem alterações; caso contrário cria um novo array (com a conversão de dtype solicitada quando especificada). Os iteráveis são convertidos como em numpy.array.

numpy.concatenate(arrays: tuple, *, axis: int = 0) → ndarray¶: Concatena uma sequência de ndarray ao longo de um axis existente. Todos os arrays de entrada devem partilhar o mesmo dtype, ndim e forma em todos os eixos exceto axis.

numpy.diag(a: ndarray, *, k: int = 0) → ndarray¶: Para um a 2-D, devolve um array 1-D contendo a diagonal de ordem k. Para um a 1-D, devolve um array quadrado 2-D com a colocado na diagonal de ordem k. k pode ser positivo (acima da diagonal principal) ou negativo (abaixo).

numpy.empty(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Alias para zeros; devolve um array preenchido com zeros de forma shape e dtype dtype. (O ulab não deixa o buffer sem inicialização.)

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Devolve um array N x M 2-D (quadrado N x N se M for None) com uns na diagonal de ordem k e zeros nos restantes elementos.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Interpreta um objeto com protocolo de buffer como um ndarray 1-D de dtype. count é o número de itens a ler (-1 lê todos os itens disponíveis); offset salta esse número de bytes no início do buffer.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Devolve um novo array de forma shape e dtype dtype com cada elemento definido como fill_value.

numpy.linspace(start: float, stop: float, num: int = 50, *, endpoint: bool = True, retstep: bool = False, dtype: int = float) → ndarray | tuple[ndarray, float]¶: Return num evenly spaced samples over the closed interval [start, stop] (or half-open if endpoint is False). When retstep is True, return a tuple (samples, step).

numpy.logspace(start: float, stop: float, num: int = 50, *, base: float = 10.0, endpoint: bool = True, dtype: int = float) → ndarray¶: Devolve num amostras igualmente espaçadas numa escala logarítmica: o resultado começa em base ** start e termina em base ** stop.

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Devolve um tuplo de matrizes de coordenadas a partir de uma sequência de arrays de coordenadas unidimensionais. Com indexing 'xy' (o padrão), as duas primeiras entradas são tratadas como coordenadas cartesianas e os seus eixos de saída são trocados; com 'ij' é usada a indexação estilo matricial. A implementação corresponde ao equivalente NumPy com copy=True e sparse=False.

numpy.ones(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Devolve um novo array de forma shape e dtype dtype preenchido com uns.

numpy.zeros(shape: int | tuple[int, ...], *, dtype: int = float) → ndarray¶: Devolve um novo array de forma shape e dtype dtype preenchido com zeros.

Inspeção / impressão¶

numpy.get_printoptions() → dict¶: Devolve as opções de impressão de arrays atuais como um dicionário com as chaves threshold e edgeitems.

numpy.set_printoptions(*, threshold: int | None = None, edgeitems: int | None = None) → None¶: Define as opções de impressão de arrays. threshold é o número máximo de elementos de array impressos na íntegra; edgeitems é o número de itens mostrados em cada extremidade de um eixo quando o array é resumido.

numpy.ndinfo(array: ndarray) → None¶: Imprime informações de diagnóstico (forma, strides, dtype, itemsize, …) sobre array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Devolve o número de elementos de a ao longo de axis; se axis for None, devolve o número total de elementos (o produto de ndarray.shape).

Comparação¶

numpy.clip(a: ndarray | int | float, a_min: ndarray | int | float, a_max: ndarray | int | float) → ndarray | int | float¶: Limita os valores de a de forma a que a_min <= result <= a_max. Equivalente a maximum(a_min, minimum(a, a_max)); o broadcasting segue as mesmas regras que minimum.

numpy.equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: x1 == x2 elemento a elemento; devolve um ndarray booleano (ou um escalar bool se ambas as entradas forem escalares). Fornecido por portabilidade – o operador == em arrays dá o mesmo resultado.

numpy.not_equal(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | bool¶: x1 != x2 elemento a elemento; a contraparte booleana de equal.

numpy.isfinite(x: ndarray | int | float) → ndarray | bool¶: Devolve um array booleano (ou escalar) que é True onde a entrada é finita. As entradas inteiras são sempre finitas.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Devolve um array booleano (ou escalar) que é True onde a entrada é infinita. As entradas inteiras nunca são infinitas.

numpy.maximum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Máximo elemento a elemento de dois arrays / escalares. Os argumentos são difundidos em conjunto; se os dtypes forem diferentes, a saída é promovida.

numpy.minimum(x1: ndarray | int | float, x2: ndarray | int | float) → ndarray | int | float¶: Mínimo elemento a elemento de dois arrays / escalares; contraparte de maximum.

numpy.nonzero(a: ndarray) → tuple[ndarray, ...]¶: Devolve um tuplo de ndarray, um por dimensão de a, contendo os índices dos elementos não nulos de a.

numpy.where(condition: ndarray | int | float, x: ndarray | int | float, y: ndarray | int | float) → ndarray¶: Devolve um ndarray cujos elementos provêm de x onde condition é verdadeira, e de y caso contrário. As três entradas são difundidas em conjunto; o dtype de saída é a promoção de x e y.

Reduções numéricas¶

numpy.all(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Testa se todos os elementos ao longo de axis avaliam como True. Com axis=None (o padrão), o array achatado é testado e é devolvido um único bool.

numpy.any(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | bool¶: Testa se algum elemento ao longo de axis avalia como True. Com axis=None, o array achatado é testado.

numpy.argmax(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Devolve o índice do elemento máximo ao longo de axis. Com axis=None, o array é achatado e é devolvido um único inteiro.

numpy.argmin(a: ndarray | list | tuple, *, axis: int | None = None) → ndarray | int¶: Devolve o índice do elemento mínimo ao longo de axis. Com axis=None, o array é achatado e é devolvido um único inteiro.

numpy.argsort(a: ndarray, *, axis: int = -1) → ndarray¶: Devolve um ndarray de índices inteiros sem sinal cujas entradas ordenam a por ordem crescente ao longo de axis. O dtype de saída é uint16, pelo que nenhum eixo pode exceder 65535 elementos. axis=None não é suportado.

numpy.cross(a: ndarray, b: ndarray) → ndarray¶: Devolve o produto vetorial de dois arrays 1-D de comprimento 3.

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Devolve a n-ésima diferença finita discreta de a ao longo de axis. n deve estar em 0..9 (o stencil de diferenciação é armazenado num int8); o comprimento de axis reduz-se em n. As palavras-chave numpy prepend e append não estão implementadas.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Devolve um novo array com a ordem dos elementos invertida ao longo de axis; com axis=None, o array é invertido ao longo de todos os eixos.

numpy.max(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Devolve o elemento máximo ao longo de axis. Com axis=None (o padrão), o array achatado é reduzido a um escalar. A palavra-chave numpy out não está implementada.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Devolve o elemento mínimo ao longo de axis; contraparte de max.

numpy.mean(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | float¶: Devolve a média aritmética ao longo de axis. Com axis=None (o padrão), a média do array achatado é devolvida como float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Devolve a mediana ao longo de axis. Com axis=None, o array é achatado primeiro. O dtype de saída é sempre float.

numpy.roll(a: ndarray, shift: int, *, axis: int | None = None) → ndarray¶: Devolve a com os seus elementos deslocados ciclicamente (rotação) em shift posições. Com axis=None (o padrão), o array é achatado primeiro. Deslocamentos negativos rodam na direção oposta.

numpy.sort(a: ndarray, *, axis: int = -1) → ndarray¶: Devolve uma cópia ordenada de a ao longo de axis usando heap sort. Com axis=None, o array é achatado primeiro. As palavras-chave numpy kind e order não estão implementadas.

numpy.std(a: ndarray | list | tuple, *, axis: int | None = None, ddof: int = 0, keepdims: bool = False) → ndarray | float¶: Devolve o desvio padrão ao longo de axis. ddof é o delta dos graus de liberdade – o divisor utilizado é N - ddof.

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Devolve a soma ao longo de axis. Com axis=None, o total do array achatado é devolvido como escalar.

Estatísticas¶

numpy.bincount(x: ndarray, *, weights: ndarray | None = None, minlength: int | None = None) → ndarray¶: Conta o número de ocorrências de cada valor no array unidimensional de inteiros não negativos x. O dtype de x deve ser uint8 ou uint16. Se weights for fornecido, cada entrada de x contribui com o seu peso correspondente em vez de 1 e a saída é do dtype float; caso contrário, a saída é do dtype uint16. Se minlength for fornecido, o array de saída tem pelo menos esse número de elementos (as entradas extra são zero).

numpy.trace(m: ndarray) → int | float¶: Devolve a soma dos elementos da diagonal da matriz quadrada m. O tipo de devolução segue o dtype de m (arrays inteiros produzem um int, arrays float produzem um float).

Transformação¶

numpy.compress(condition: ndarray | list | tuple, a: ndarray, *, axis: int | None = None) → ndarray¶: Devolve fatias de a selecionadas ao longo de axis pela condition booleana. Com axis=None, é utilizado o array achatado.

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Devolve uma cópia de a com as entradas em indices removidas ao longo de axis. Com axis=None, o array é achatado primeiro. Índices negativos contam a partir do fim de axis; indices é ordenado internamente antes da eliminação.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Devolve o produto escalar de dois arrays. Para dois arrays 1-D, é o produto interno (um escalar float). Para arrays 2-D, é a multiplicação de matrizes; as dimensões internas devem corresponder. O resultado é sempre do dtype float.

Aproximação¶

numpy.interp(x: ndarray, xp: ndarray, fp: ndarray, *, left: float | None = None, right: float | None = None) → ndarray¶: Interpolação linear unidimensional. xp deve ser um array 1-D monotonicamente crescente de valores independentes; fp contém os valores dependentes correspondentes; x são os pontos em que o interpolante é avaliado. left e right substituem o valor devolvido para x < xp[0] e x > xp[-1] respetivamente (por omissão: fp[0] e fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integra y usando a regra trapezoidal composta. Se x for fornecido, indica as posições das amostras correspondentes a y; caso contrário, é utilizado o espaçamento dx. y (e x) devem ser 1-D.

Seleção¶

numpy.take(a: ndarray, indices: ndarray | list | tuple, *, axis: int | None = None, out: ndarray | None = None, mode: str | None = None) → ndarray¶: Extrai elementos de a nos indices fornecidos ao longo de axis. Com axis=None, é utilizado o array achatado. mode seleciona o comportamento fora dos limites: "raise" (padrão – gera ValueError), "wrap" (módulo do comprimento do eixo), ou "clip" (limita ao intervalo válido; índices negativos não são permitidos). Se out for fornecido, o resultado é escrito no mesmo.

Bit a bit¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: AND bit a bit elemento a elemento de dois arrays inteiros; o broadcasting é suportado. Um dtype não inteiro gera uma exceção.

numpy.bitwise_or(x1: ndarray, x2: ndarray) → ndarray¶: OR bit a bit elemento a elemento de dois arrays inteiros.

numpy.bitwise_xor(x1: ndarray, x2: ndarray) → ndarray¶: XOR bit a bit elemento a elemento de dois arrays inteiros.

numpy.left_shift(x1: ndarray, x2: ndarray) → ndarray¶: Deslocamento bit a bit de x1 para a esquerda em x2 bits elemento a elemento; ambos os arrays devem ter dtype inteiro.

numpy.right_shift(x1: ndarray, x2: ndarray) → ndarray¶: Deslocamento bit a bit de x1 para a direita em x2 bits elemento a elemento; ambos os arrays devem ter dtype inteiro.

Filtragem¶

numpy.convolve(a: ndarray, v: ndarray) → ndarray¶: Devolve a convolução linear discreta de dois arrays 1-D. Apenas o modo "full" é suportado; a palavra-chave numpy mode não é aceite (outros modos podem ser obtidos fatiando o resultado completo). O comprimento de saída é len(a) + len(v) - 1.

Polinomial¶

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

numpy.polyfit(y: ndarray | list | tuple, deg: int) → ndarray: Ajusta um polinómio de grau deg aos pontos de dados (x, y) por mínimos quadrados e devolve os coeficientes do polinómio (do grau mais alto para o mais baixo). Se x for omitido, é usado range(len(y)). Gera ValueError se os comprimentos de x e y forem diferentes.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Avalia o polinómio cujos coeficientes são p (do grau mais alto para o mais baixo) em x. Se x for um escalar, é devolvido um float, caso contrário um ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Lê um array previamente gravado com save a partir de file (formato .npy independente de plataforma do numpy). A ordem dos bytes é convertida a tempo de execução se a ordem do ficheiro for diferente da do anfitrião.

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¶: Lê dados numéricos de um file de texto e devolve-os como um ndarray. delimiter tem por omissão o espaço em branco; comments é o marcador de comentário de linha; max_rows limita o número de linhas de dados lidas (-1 para todas); usecols seleciona colunas por índice; skiprows salta esse número de linhas iniciais. Se dtype não for float, os valores são convertidos por arredondamento.

numpy.save(file: str, a: ndarray) → None¶: Guarda a em file no formato .npy independente de plataforma do numpy.

numpy.savetxt(file: str, a: ndarray, *, delimiter: str = ' ', header: str | None = None, footer: str | None = None, comments: str = '# ') → None¶: Escreve a em file como texto. delimiter separa valores dentro de uma linha; header e footer, se fornecidos, são escritos antes/depois dos dados, cada um prefixado por comments. Os valores são escritos como ponto flutuante.

Funções universais¶

Funções matemáticas elemento a elemento. Cada uma aceita um escalar ou um ndarray e devolve um resultado com a mesma forma (um escalar float para entradas escalares, um ndarray para entradas em array). Quando chamada com um ndarray, o resultado é um novo ndarray de ponto flutuante; pode ser passada uma palavra-chave opcional out para escrever o resultado num ndarray float pré-alocado do mesmo tamanho.

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Calcula o arco cosseno (cosseno inverso) de cada elemento de x; o resultado está em radianos.

numpy.acosh(x: ndarray | float, /) → ndarray | float¶: Calcula o cosseno hiperbólico inverso de cada elemento de x.

numpy.arctan2(y: ndarray | float, x: ndarray | float, /) → ndarray | float¶: Calcula o arco tangente de dois argumentos atan2(y, x) elemento a elemento; suporta broadcasting entre as duas entradas.

numpy.around(x: ndarray, /, decimals: int = 0) → ndarray¶: Arredonda os elementos do ndarray x ao número dado de decimals; o primeiro argumento deve ser um ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Calcula o arco seno (seno inverso) de cada elemento de x; o resultado está em radianos.

numpy.asinh(x: ndarray | float, /) → ndarray | float¶: Calcula o seno hiperbólico inverso de cada elemento de x.

numpy.atan(x: ndarray | float, /) → ndarray | float¶: Calcula o arco tangente (tangente inversa) de cada elemento de x; o resultado está em radianos.

numpy.atanh(x: ndarray | float, /) → ndarray | float¶: Calcula a tangente hiperbólica inversa de cada elemento de x.

numpy.ceil(x: ndarray | float, /) → ndarray | float¶: Calcula o teto (menor inteiro não inferior ao valor) de cada elemento de x.

numpy.cos(x: ndarray | float, /) → ndarray | float¶: Calcula o cosseno de cada elemento de x (em radianos).

numpy.cosh(x: ndarray | float, /) → ndarray | float¶: Calcula o cosseno hiperbólico de cada elemento de x.

numpy.degrees(x: ndarray | float, /) → ndarray | float¶: Converte cada elemento de x de radianos para graus.

numpy.exp(x: ndarray | float, /) → ndarray | float¶: Compute the exponential e**x of each element of x.

numpy.expm1(x: ndarray | float, /) → ndarray | float¶: Calcula exp(x) - 1 de cada elemento de x com maior precisão próximo de zero.

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Calcula o piso (maior inteiro não superior ao valor) de cada elemento de x.

numpy.log(x: ndarray | float, /) → ndarray | float¶: Calcula o logaritmo natural de cada elemento de x.

numpy.log10(x: ndarray | float, /) → ndarray | float¶: Calcula o logaritmo de base 10 de cada elemento de x.

numpy.log2(x: ndarray | float, /) → ndarray | float¶: Calcula o logaritmo de base 2 de cada elemento de x.

numpy.radians(x: ndarray | float, /) → ndarray | float¶: Converte cada elemento de x de graus para radianos.

numpy.sin(x: ndarray | float, /) → ndarray | float¶: Calcula o seno de cada elemento de x (em radianos).

numpy.sinc(x: ndarray | float, /) → ndarray | float¶: Calcula a função sinc normalizada sin(pi*x) / (pi*x) de cada elemento de x.

numpy.sinh(x: ndarray | float, /) → ndarray | float¶: Calcula o seno hiperbólico de cada elemento de x.

numpy.sqrt(x: ndarray | float, /, *, dtype: int = float) → ndarray | float¶: Compute the square root of each element of x.

numpy.tan(x: ndarray | float, /) → ndarray | float¶: Calcula a tangente de cada elemento de x (em radianos).

numpy.tanh(x: ndarray | float, /) → ndarray | float¶: Calcula a tangente hiperbólica de cada elemento de x.

numpy.vectorize(f: Callable[[float], float], /, *, otypes: int | None = None) → Callable¶: Devolve um callable que aplica a função Python f elemento a elemento a um escalar, iterável ou ndarray; otypes seleciona o dtype de saída (por omissão float).

Constantes¶

numpy.e: float¶: O número de Euler \(e \approx 2.71828\).

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

numpy.inf: float¶: Infinito positivo em vírgula flutuante IEEE-754.

numpy.nan: float¶: «Não é um número» em vírgula flutuante IEEE-754.

numpy.bool: int¶: Código dtype para arrays booleanos (armazenados como uint8).

numpy.uint8: int¶: Código dtype para arrays de inteiros de 8 bits sem sinal.

numpy.int8: int¶: Código dtype para arrays de inteiros de 8 bits com sinal.

numpy.uint16: int¶: Código dtype para arrays de inteiros de 16 bits sem sinal.

numpy.int16: int¶: Código dtype para arrays de inteiros de 16 bits com sinal.

numpy.float: int¶: Código dtype para arrays de ponto flutuante de 32 bits.

numpy — operações em arrays compatíveis com numpy¶