`numpy` — operações de array 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. Ele implementa um subconjunto selecionado do numpy do CPython: construção de arrays, matemática 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)))

Cada argumento dtype é uma das constantes inteiras expostas no nível do módulo: numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float (o padrão) e (quando o suporte a complexos é compilado) numpy.complex. O tipo de resultado ndarray refere-se a numpy.ndarray.

Submódulos¶

classe `ndarray` — o array n-dimensional¶

O ndarray é o contêiner n-dimensional, ciente de dtype, no núcleo do numpy / ulab. Os dados são armazenados em um bloco contíguo cuja interpretação é descrita por um pequeno cabeçalho (dtype, shape, strides, ndim, itemsize). Muitas operações – reshape, transpose, fatiamento – apenas ajustam esse cabeçalho e, portanto, são muito baratas; métodos que alocam novo armazenamento (copy, flatten, a maioria da aritmética) retornam um novo array denso.

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

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

Cria um novo ndarray.

Parâmetros:

values – Dados de origem. Pode ser outro ndarray (que é copiado em profundidade, 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 todos ter o mesmo comprimento ou um ValueError é levantado.
dtype – Tipo de elemento para o novo array. Um dos inteiros de código de tipo expostos por numpy (numpy.bool, numpy.uint8, numpy.int8, numpy.uint16, numpy.int16, numpy.float e – quando suportado – numpy.complex), ou uma instância de dtype. O padrão é numpy.float.

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

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

Inverte a ordem dos bytes de cada elemento. Para arrays uint16, int16, float e complex isso inverte a ordem de bytes por elemento, o que é útil ao consumir dados de periféricos cuja endianness não corresponde à do microcontrolador. Para dtypes de byte único (bool, uint8, int8) isso é uma operação nula que retorna uma view ou cópia.

Se inplace for False (o padrão), um novo ndarray é retornado e o original é deixado intacto. Se inplace for True, os bytes de self são invertidos no local e uma view de self é retornada.

copy() → ndarray¶: Retorna uma nova cópia densa e profunda do array. A cópia possui seus próprios dados; modificações nela não afetam o original.

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

Retorna uma nova cópia unidimensional do array.

Parâmetros:: order – 'C' (o padrão) percorre os dados na ordem C (o último eixo varia mais rápido); 'F' percorre na ordem Fortran (o primeiro eixo varia mais rápido).

reshape(shape: int | tuple[int, ...]) → ndarray¶: Retorna uma view do array com um novo formato. O número total de elementos deve permanecer inalterado ou um ValueError é levantado. 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 primeiro achata o array e depois ordena.

tobytes() → bytearray¶: Retorna um bytearray que faz alias do buffer de dados subjacente do array. Escritas através do bytearray retornado modificam o array no local. Levanta ValueError se o array não for denso (por exemplo, uma view fatiada).

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

transpose() → ndarray¶: Retorna a transposta do array (eixos invertidos). Para arrays unidimensionais isso retorna self. Disponível apenas quando ULAB_MAX_DIMS > 1. O atributo T é uma forma abreviada deste método.

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

flat: flatiter¶: Um iterador plano que produz cada elemento do array na ordem C. Diferentemente de flatten(), iterar sobre 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 uma tupla 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 avançar na memória ao longo de cada eixo para alcançar o próximo elemento ao longo desse eixo.

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

real: ndarray¶: A parte real de um array complexo, retornada como um ndarray float. Para arrays reais isso é uma cópia de self com o mesmo dtype. Disponível apenas quando o firmware foi compilado com suporte a complexos.

imag: ndarray¶: A parte imaginária de um array complexo, retornada como um ndarray float. Para arrays reais isso é um array de zeros com o mesmo dtype que self. Disponível apenas quando o firmware foi compilado com suporte a complexos.

Operadores suportados¶

Instâncias de ndarray suportam os seguintes operadores. Operadores binários fazem broadcast de seus operandos seguindo as regras padrão de broadcasting do numpy e seguem as regras de upcasting do numpy (por exemplo, uint8 + int8 => int16, uint16 + int16 => float); operações envolvendo um operando complexo produzem um resultado complexo.

Aritméticos (binários): +, -, *, /, //, %, **. Operandos refletidos (do lado direito) e as variantes no local +=, -=, *=, /=, %=, **= também são suportados. Tanto as formas ndarray-com-ndarray quanto ndarray-com-escalar são aceitas. A divisão inteira (//) e o operador de módulo (%) não são implementados para arrays complex.

Comparação: ==, !=, <, <=, >, >=. Cada um retorna um ndarray booleano do formato de broadcast.

Bit a bit (apenas arrays inteiros): &, |, ^. Aplicar estes a um array float ou complex levanta TypeError.

Unários: + (retorna uma cópia), - (negação; em dtypes sem sinal os valores envolvem módulo \(2^N\)), abs() (valor absoluto elemento a elemento; em dtypes sem sinal retorna uma cópia sem computação), ~ (inversão bit a bit, apenas dtypes inteiros), len() (retorna 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 de inteiros (fancy) são todas suportadas tanto em leituras quanto em escritas.

Iteração: Iterar sobre um ndarray produz subarrays ao longo do primeiro eixo (um elemento por 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 é implementado; use numpy.dot (np.dot(a, b)) em vez disso.

Os operadores de deslocamento (<<, >>) não são implementados no nível de operador. Use numpy.left_shift e numpy.right_shift para deslocamentos de 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¶: Retorna valores uniformemente espaçados ao longo do intervalo semiaberto [start, stop). Se apenas um argumento posicional for fornecido, ele é tratado como stop com start = 0. Se dtype for omitido, ele é inferido a partir das entradas (inteiro se todos de start, stop, step forem inteiros e 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), retorna a inalterado; caso contrário cria um novo array (com a conversão de dtype solicitada quando fornecida). Iteráveis são convertidos como em numpy.array.

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

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

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

numpy.eye(N: int, M: int | None = None, k: int = 0, *, dtype: int = float) → ndarray¶: Retorna um array 2-D N x M (quadrado N x N se M for None) com uns na k-ésima diagonal e zeros nas demais posições.

numpy.frombuffer(buffer: bytes, *, dtype: int = float, count: int = -1, offset: int = 0) → ndarray¶: Interpreta um objeto de 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 pula essa quantidade de bytes no início do buffer.

numpy.full(shape: int | tuple[int, ...], fill_value: int | float | bool, *, dtype: int = float) → ndarray¶: Retorna um novo array de shape e 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]¶: Retorna num amostras uniformemente espaçadas ao longo do intervalo fechado [start, stop] (ou semiaberto se endpoint for False). Quando retstep for True, retorna uma tupla (samples, step). start/stop complexos produzem um array complexo (quando o suporte a complexos está habilitado).

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

numpy.meshgrid(*xi: ndarray, indexing: str = 'xy') → tuple[ndarray, ...]¶: Retorna uma tupla 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 seus eixos de saída são trocados; com 'ij' é usada a indexação estilo matriz. A implementação corresponde ao equivalente do NumPy com copy=True e sparse=False.

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

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

Inspeção / impressão¶

numpy.get_printoptions() → dict¶: Retorna as opções atuais de impressão de arrays como um dict 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 do array impressos por completo; 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 (formato, strides, dtype, itemsize, …) sobre array.

numpy.size(a: ndarray, *, axis: int | None = None) → int¶: Retorna o número de elementos de a ao longo de axis; se axis for None, retorna 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 modo 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; retorna 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¶: Retorna um array booleano (ou escalar) que é True onde a entrada é finita. Entradas inteiras são sempre finitas.

numpy.isinf(x: ndarray | int | float) → ndarray | bool¶: Retorna um array booleano (ou escalar) que é True onde a entrada é infinita. 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 sofrem broadcast em conjunto; se os dtypes diferirem, a saída sofre upcast.

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, ...]¶: Retorna uma tupla 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¶: Retorna um ndarray cujos elementos vêm de x onde condition é verdadeiro, e de y caso contrário. As três entradas sofrem broadcast em conjunto; o dtype de saída é o upcast 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 um único bool é retornado.

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¶: Retorna o índice do elemento máximo ao longo de axis. Com axis=None o array é achatado e um único inteiro é retornado.

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

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

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

numpy.diff(a: ndarray, *, n: int = 1, axis: int = -1) → ndarray¶: Retorna a n-ésima diferença discreta direta de a ao longo de axis. n deve estar em 0..9 (o estêncil de diferenciação é armazenado em um int8); o comprimento de axis encolhe em n. As palavras-chave prepend e append do numpy não são implementadas.

numpy.flip(a: ndarray, *, axis: int | None = None) → ndarray¶: Retorna 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¶: Retorna o elemento máximo ao longo de axis. Com axis=None (o padrão) o array achatado é reduzido a um escalar. A palavra-chave out do numpy não é implementada.

numpy.min(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Retorna 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¶: Retorna a média aritmética ao longo de axis. Com axis=None (o padrão) a média do array achatado é retornada como um float.

numpy.median(a: ndarray, *, axis: int | None = None) → ndarray | float¶: Retorna 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¶: Retorna a com seus elementos rolados (deslocados ciclicamente) por shift posições. Com axis=None (o padrão) o array é achatado primeiro. Deslocamentos negativos rolam na direção oposta.

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

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

numpy.sum(a: ndarray | list | tuple, *, axis: int | None = None, keepdims: bool = False) → ndarray | int | float¶: Retorna a soma ao longo de axis. Com axis=None o total do array achatado é retornado como um 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 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 essa quantidade de elementos (as entradas extras são zero).

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

Transformação¶

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

numpy.delete(a: ndarray, indices: int | ndarray | list | tuple | range, *, axis: int | None = None) → ndarray¶: Retorna 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 remoção.

numpy.dot(m1: ndarray, m2: ndarray) → ndarray | float¶: Retorna o produto escalar de dois arrays. Para dois arrays 1-D este é o produto interno (um escalar float). Para arrays 2-D este é 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 nos quais o interpolante é avaliado. left e right substituem o valor retornado para x < xp[0] e x > xp[-1] respectivamente (padrões: fp[0] e fp[-1]).

numpy.trapz(y: ndarray, x: ndarray | None = None, dx: float = 1.0) → float¶: Integra y usando a regra do trapézio composta. Se x for fornecido, ele provê as posições das amostras correspondentes a y; caso contrário o espaçamento dx é usado. 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¶: Pega elementos de a nos indices dados ao longo de axis. Com axis=None o array achatado é usado. mode seleciona o comportamento fora dos limites: "raise" (padrão – levanta 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 nele.

Bit a bit¶

numpy.bitwise_and(x1: ndarray, x2: ndarray) → ndarray¶: AND bit a bit elemento a elemento de dois arrays inteiros; broadcasting é suportado. Um dtype não inteiro levanta 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 elemento a elemento de x1 para a esquerda por x2 bits; ambos os arrays devem ter dtype inteiro.

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

Filtragem¶

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

Polinômio¶

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 retorna os coeficientes do polinômio (maior grau primeiro). Se x for omitido, range(len(y)) é usado. Levanta ValueError se os comprimentos de x e y diferirem.

numpy.polyval(p: ndarray | list | tuple, x: ndarray | list | tuple | int | float) → ndarray | float¶: Avalia o polinômio cujos coeficientes são p (maior grau primeiro) em x. Se x for um escalar, um float é retornado, caso contrário um ndarray.

I/O¶

numpy.load(file: str) → ndarray¶: Lê um array previamente escrito com save a partir de file (formato .npy independente de plataforma do numpy). A endianness é convertida em tempo real se a ordem de bytes do arquivo diferir da do 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¶: Lê dados numéricos de um file de texto e os retorna como um ndarray. delimiter assume por padrã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 pula essa quantidade de linhas iniciais. Se dtype não for float, os valores são convertidos por arredondamento.

numpy.save(file: str, a: ndarray) → None¶: Salva 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.

Auxiliares de complexos¶

Estas funções só estão disponíveis quando o ulab foi compilado com suporte a complexos (ULAB_SUPPORTS_COMPLEX).

numpy.real(val: ndarray) → ndarray¶: Retorna a parte real de val. Para uma entrada de dtype real, retorna uma cópia preservando o dtype; para uma entrada complexa, retorna um ndarray float.

numpy.imag(val: ndarray) → ndarray¶: Retorna a parte imaginária de val. Para uma entrada de dtype real, retorna um array de zeros com o mesmo dtype; para uma entrada complexa, retorna um ndarray float.

numpy.conjugate(val: ndarray | complex | int | float) → ndarray | complex | int | float¶: Retorna o conjugado complexo de val. Entradas de valor real são retornadas inalteradas.

numpy.sort_complex(a: ndarray) → ndarray¶: Ordena o array 1-D a primeiro pela parte real, depois pela parte imaginária. O resultado é sempre de dtype complexo, mesmo que a fosse de valor real.

Funções universais¶

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

numpy.acos(x: ndarray | float, /) → ndarray | float¶: Calcula o cosseno inverso (arco cosseno) 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 a tangente inversa 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 para o número dado de decimals; o primeiro argumento deve ser um ndarray.

numpy.asin(x: ndarray | float, /) → ndarray | float¶: Calcula o seno inverso (arco seno) 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 a tangente inversa (arco tangente) 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 menor que o 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¶: Calcula a exponencial e**x de cada elemento de x; pode retornar um ndarray complexo quando recebe entrada complexa (se o suporte a complexos estiver habilitado).

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

numpy.floor(x: ndarray | float, /) → ndarray | float¶: Calcula o piso (maior inteiro não maior que o 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¶: Calcula a raiz quadrada de cada elemento de x; passe dtype=numpy.complex para obter resultados complexos para entradas reais negativas (se o suporte a complexos estiver habilitado).

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¶: Retorna um objeto chamável que aplica a função Python f elemento a elemento a um escalar, iterável ou ndarray; otypes seleciona o dtype de saída (padrão float).

Constantes¶

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

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

numpy.inf: float¶: Infinito positivo de ponto flutuante IEEE-754.

numpy.nan: float¶: “Not a number” de ponto flutuante IEEE-754.

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

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

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

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

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

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

numpy — operações de array compatíveis com numpy¶