Prefácio do tradutor

Olá a todos, aqui chegamos à parte final. Boa leitura!
Navegação:

• Parte 1
• Parte 2
• Parte 3
• O original

Polinômios matemáticos

O NumPy fornece métodos para trabalhar com polinômios. Ao passar uma lista de raízes, você pode obter os coeficientes da equação:

>>> np.poly([-1, 1, 1, 10]) array([ 1, -11, 9, 11, -10]) 

Aqui, o array retorna os coeficientes correspondentes à equação: $$ .
A operação reversa também pode ser realizada: passando a lista de coeficientes, a função raiz retornará todas as raízes do polinômio:

 >>> np.roots([1, 4, -2, 3]) array([-4.57974010+0.j , 0.28987005+0.75566815j, 0.28987005-0.75566815j]) 

Observe que nesta equação $$ duas raízes são imaginárias.
Coeficientes polinomiais podem ser integrados. Vamos considerar a integração $$ em $$ . Geralmente a constante C é zero:

 >>> np.polyint([1, 1, 1, 1]) array([ 0.25 , 0.33333333, 0.5 , 1. , 0. ]) 

Da mesma forma, derivativos podem ser tomados:

 >>> np.polyder([1./4., 1./3., 1./2., 1., 0.]) array([ 1., 1., 1., 1.]) 

As funções polyadd, polysub, polymul e polydiv também suportam a soma, subtração, multiplicação e divisão dos coeficientes polinomiais, respectivamente.
A função polivalente substitui o valor fornecido no polinômio. Considere um polinômio $$$x ^ 3 - 2x ^ 2 + 2$em x = 4:

 >>> np.polyval([1, -2, 0, 2], 4) 34 

Em conclusão, a função polyfit pode ser usada para selecionar (interpolar) um polinômio de uma determinada ordem para um conjunto de valores:

 >>> x = [1, 2, 3, 4, 5, 6, 7, 8] >>> y = [0, 2, 1, 3, 7, 10, 11, 19] >>> np.polyfit(x, y, 2) array([ 0.375 , -0.88690476, 1.05357143]) 

A matriz retornada é uma lista de coeficientes polinomiais. Funções de interpolação mais sofisticadas podem ser encontradas no SciPy.

Estatísticas

Além das funções mean, var e std, o NumPy fornece mais alguns métodos para trabalhar com estatísticas em matrizes.
A mediana pode ser encontrada assim:

 >>> a = np.array([1, 4, 3, 8, 9, 2, 3], float) >>> np.median(a) 3.0 

O coeficiente de correlação para algumas variáveis ​​é observado várias vezes e pode ser encontrado em matrizes da forma: [[x1, x2, ...], [y1, y2, ...], [z1, z2, ...], .. .], onde x, y, z são diferentes observáveis ​​quânticos e números indicam o número de "observações":

 >>> a = np.array([[1, 2, 1, 3], [5, 3, 1, 8]], float) >>> c = np.corrcoef(a) >>> c array([[ 1. , 0.72870505], [ 0.72870505, 1. ]]) 

Temos uma matriz retornada c [i, j] que armazena o coeficiente de correlação para os observáveis ​​quânticos i-ésimo j-ésimo.
Da mesma forma, o momento de covariância pode ser encontrado:

 >>> np.cov(a) array([[ 0.91666667, 2.08333333], [ 2.08333333, 8.91666667]]) 

Números aleatórios

Uma parte importante de toda simulação é a capacidade de gerar números aleatórios. Para fazer isso, usamos o gerador de números pseudo-aleatórios embutido no NumPy no submódulo aleatório. Os números são pseudo- aleatórios no sentido de que são gerados deterministicamente a partir de um número de semente, mas são dispersos em uma semelhança estatística com uma imagem aleatória. Para gerar o NumPy, utiliza um algoritmo especial chamado Mersenne Twister.
Você pode especificar o elemento gerador de uma sequência de números aleatórios da seguinte maneira:

 >>> np.random.seed(293423) 

A semente é um número inteiro. Cada programa que começa com a mesma semente gera a mesma sequência de números todas as vezes. Isso pode ser útil para depuração, mas, em geral, não precisamos definir a semente; de ​​fato, quando executamos o programa várias vezes, queremos obter uma sequência diferente de números a cada vez. Se este comando não for executado, o NumPy seleciona automaticamente uma semente aleatória (com base no tempo), que é diferente cada vez que o programa é iniciado.
Uma matriz de números aleatórios do meio intervalo [0,0, 1,0) pode ser gerada da seguinte maneira:

 >>> np.random.rand(5) array([ 0.40783762, 0.7550402 , 0.00919317, 0.01713451, 0.95299583]) 

A função rand pode ser usada para gerar matrizes bidimensionais ou a função remodelar pode ser usada:

 >>> np.random.rand(2,3) array([[ 0.50431753, 0.48272463, 0.45811345], [ 0.18209476, 0.48631022, 0.49590404]]) >>> np.random.rand(6).reshape((2,3)) array([[ 0.72915152, 0.59423848, 0.25644881], [ 0.75965311, 0.52151819, 0.60084796]]) 

Para gerar um único número aleatório no intervalo [0,0, 1,0):

 >>> np.random.random() 0.70110427435769551 

Para gerar um número inteiro aleatório no intervalo [min, max), use a função randint (min, max):

 >>> np.random.randint(5, 10) 9 

Em cada um de nossos exemplos, geramos números a partir de uma distribuição uniforme contínua. O NumPy também inclui geradores para outras distribuições, como: Beta, binomial, qui-quadrado, Dirichlet, exponencial, Fischer, Gamma, geométrica, Gambal, hipergeométrica, Laplace, logística, lognormal, lognormal, logarítmica, multinomial, normal multidimensional, binomial negativa, não central qui-quadrado, Fischer descentralizado, normal (Gauss), Pareto, Poisson, poder, Rayleigh, Cauchy, estudante, triangular, Von Mies, Wald, Weibull e Zipf. Vejamos dois exemplos.
Para gerar a partir de uma distribuição Poisson discreta em λ = 6,0,

 >>> np.random.poisson(6.0) 5 

Para gerar um número da distribuição normal (Gaussiana) com um valor médio de μ = 1,5 e desvio padrão σ = 4,0:

 >>> np.random.normal(1.5, 4.0) 0.83636555041094318 

Para obter um número da distribuição normal (μ = 0, σ = 1), sem especificar argumentos:

 >>> np.random.normal() 0.27548716940682932 

Para gerar vários valores, use o argumento size:

 >>> np.random.normal(size=5) array([-1.67215088, 0.65813053, -0.70150614, 0.91452499, 0.71440557]) 

O módulo para gerar números aleatórios também pode ser usado para distribuir valores aleatoriamente em uma lista. Isso pode ser útil se quisermos distribuir valores aleatoriamente em uma lista:

 >>> l = range(10) >>> l [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] >>> np.random.shuffle(l) >>> l [4, 9, 5, 0, 2, 7, 6, 8, 1, 3] 

Observe que a função aleatória modifica uma matriz existente e não retorna uma nova.

Algumas informações adicionais

O NumPy inclui muitos outros recursos que não mencionamos aqui. Em particular, essas são funções para trabalhar com a transformada de Fourier discreta, operações mais complexas em álgebra linear, testar matrizes para tamanho / dimensão / tipo, dividir e conectar matrizes, histogramas, criar matrizes a partir de qualquer dado de diferentes maneiras, criar e operar matrizes de grade , com valores especiais (NaN, Inf), operações de conjunto, a criação de diferentes tipos de matrizes especiais e o cálculo de funções matemáticas especiais (por exemplo: funções de Bessel). Você também pode ver a documentação do NumPy para obter detalhes mais precisos.

Módulos SciPy

O SciPy estende muito bem a funcionalidade do NumPy. Não falaremos sobre seus detalhes, mas consideraremos algumas de suas possibilidades. A maioria das funções SciPy estão disponíveis após a importação do módulo:

 >>> import scipy 

A função de ajuda fornece informações úteis sobre o SciPy:

>>> help(scipy)
Help on package scipy:

NAME
scipy
FILE
c:\python25\lib\site-packages\scipy\__init__.py
DESCRIPTION
SciPy --- A scientific computing package for Python
===================================================
Documentation is available in the docstrings and
online at http://docs.scipy.org.

Contents
--------
SciPy imports all the functions from the NumPy namespace, and in
addition provides:

Available subpackages
---------------------
odr --- Orthogonal Distance Regression [*]
misc --- Various utilities that don't have
another home.sparse.linalg.eigen.arpack --- Eigenvalue solver using iterative methods. [*]
fftpack --- Discrete Fourier Transform algorithms[*]
io --- Data input and output [*]
sparse.linalg.eigen.lobpcg --- Locally Optimal Block Preconditioned Conjugate Gradient Method (LOBPCG) [*]
special --- Airy Functions [*]
lib.blas --- Wrappers to BLAS library [*]
sparse.linalg.eigen --- Sparse Eigenvalue Solvers [*]
stats --- Statistical Functions [*]
lib --- Python wrappers to external libraries [*]
lib.lapack --- Wrappers to LAPACK library [*]
maxentropy --- Routines for fitting maximum entropymodels [*]
integrate --- Integration routines [*]
ndimage --- n-dimensional image package [*]
linalg --- Linear algebra routines [*]
spatial --- Spatial data structures and algorithms[*]
interpolate --- Interpolation Tools [*]
sparse.linalg --- Sparse Linear Algebra [*]
sparse.linalg.dsolve.umfpack --- :Interface to the UMFPACK library: [*]
sparse.linalg.dsolve --- Linear Solvers [*]
optimize --- Optimization Tools [*]
cluster --- Vector Quantization / Kmeans [*]
signal --- Signal Processing Tools [*]
sparse --- Sparse Matrices [*]
[*] - using a package requires explicit import (see pkgload)
...

Observe que alguns submódulos precisam diretamente de importação adicional, marcada com uma estrela:

 >>> import scipy >>> import scipy.interpolate 

As funções em cada módulo estão bem documentadas em documentos internos e na documentação oficial. A maioria deles fornece diretamente funções para trabalhar com algoritmos numéricos e são muito fáceis de usar. Assim, o SciPy pode economizar uma quantidade gigantesca de tempo em cálculos científicos, porque Ele já fornece funções escritas e testadas.
Não consideraremos o SciPy em detalhes, mas a tabela abaixo abordará alguns de seus recursos:

Módulo	Para que é utilizado
scipy.constants	Conjunto de constantes matemáticas e físicas
scipy.special	Muitas funções especiais da física matemática, tais como: arejado, elíptico, Bessel, gama, beta, hipergeométrico, cilindro parabólico, Mathieu, onda esférica, Struve, Kelvin.
scipy.integrate	Funções para trabalhar com integração numérica usando os métodos trapézio, Simpson, Romberg e outros. Também fornece métodos para trabalhar com equações diferenciais completas.
scipy.optimize	Métodos padrão alto / baixo para trabalhar com funções genéricas do usuário. Os algoritmos incluíram: Nelder - Mead, Pull ( Powell ), gradientes conjugados, Bruden - Fletcher - Goldfarb - Channo, mínimos quadrados, otimização condicional, recozimento simulado, recozimento simulado, pesquisa exaustiva, Brent, Newton, bissecção, Broyden, Anderson e pesquisa linear.
scipy.linalg	Funcionalidade mais ampla para trabalhar com álgebra linear do que no NumPy. Fornece mais opções para o uso de funções especiais e rápidas para objetos específicos (por exemplo: uma matriz de três diagonais). Métodos incluídos: pesquisa de uma matriz não degenerada, pesquisa de uma solução determinante de sistemas lineares de equações, cálculo de normas e matriz pseudo-inversa, decomposição espectral, decomposição singular, decomposição LU, decomposição LU, decomposição Cholesky, decomposição QR, decomposição Schur e muitas outras operações matemáticas para trabalhar com matrizes.
scipy.sparse	Funções para trabalhar com grandes matrizes esparsas
scipy.interpolate	Métodos e classes para interpolar objetos que podem ser usados ​​para dados numéricos discretos. A interpolação linear e spline ( tradutor de notas: representação matemática de curvas suaves ) está disponível para conjuntos de dados unidimensionais e bidimensionais.
scipy.fftpack	Métodos para processar transformadas de Fourier.
scipy.signal	Métodos para processar sinais, por exemplo: convolução de funções, correlação, transformada de Fourier discreta, suavização de spline B, filtragem, etc., etc.
scipy.stats	Uma grande biblioteca de funções e distribuições estatísticas para trabalhar com conjuntos de dados.

Um grande grupo de desenvolvedores continua desenvolvendo continuamente novos recursos SciPy. Uma boa abordagem prática é a seguinte: se você está pensando em implementar quaisquer funções e métodos numéricos no seu código, pode primeiro examinar a documentação SciPy original. Existe a possibilidade de alguém já ter implementado e contribuído para o SciPy.

Posfácio

Nossa série de artigos chegou ao fim. Obrigado a todos que leram e tiraram um tempo. Espero também que você tenha trazido algumas informações úteis e aprendido algo novo. Continue a desenvolver e aprender coisas novas! Até breve.