Prefacio del traductor

Hola a todos, aquí llegamos a la parte final. Que tengas una buena lectura!
Navegación:

Polinomios matemáticos

NumPy proporciona métodos para trabajar con polinomios. Al pasar una lista de raíces, puede obtener los coeficientes de la ecuación:

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

Aquí, la matriz devuelve los coeficientes correspondientes a la ecuación:

x^{4} - 11 x^{3} + 9 x^{2} + 11 x - 10

$x ^ 4 - 11x ^ 3 + 9x ^ 2 + 11x - 10$ .
La operación inversa también se puede realizar: pasando la lista de coeficientes, la función raíz devolverá todas las raíces del polinomio:

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

Tenga en cuenta que en esta ecuación

x^{3} + 4 x^{2} - 2 x + 3

$x ^ 3 + 4x ^ 2 - 2x + 3$ Dos raíces son imaginarias.
Los coeficientes polinomiales pueden integrarse. Consideremos la integración

x^{3} + x^{2} + x + 1

$x ^ 3 + x ^ 2 + x + 1$ en

x^{4} / 4 + x^{3} / 3 + x^{2} / 2 + x + C

$x ^ 4/4 + x ^ 3/3 + x ^ 2/2 + x + C$ . Por lo general, la constante C es cero:

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

Del mismo modo, se pueden tomar derivados:

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

Las funciones polyadd, polysub, polymul y polydiv también admiten la suma, resta, multiplicación y división de coeficientes polinómicos, respectivamente.
La función polivalente sustituye el valor dado en el polinomio. Considera un polinomio

x^{3} - 2 x^{2} + 2

$x ^ 3 - 2x ^ 2 + 2$ en x = 4:

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

En conclusión, la función polyfit se puede usar para seleccionar (interpolar) un polinomio de un orden dado a un 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])

La matriz devuelta es una lista de coeficientes polinómicos. Se pueden encontrar funciones de interpolación más sofisticadas en SciPy.

Estadísticas

Además de las funciones mean, var y std, NumPy proporciona algunos métodos más para trabajar con estadísticas en matrices.
La mediana se puede encontrar así:

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

El coeficiente de correlación para algunas variables se observa varias veces y se puede encontrar en matrices de la forma: [[x1, x2, ...], [y1, y2, ...], [z1, z2, ...], .. .], donde x, y, z son observables cuánticos diferentes y los números indican el número de "observaciones":

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

Tenemos una matriz devuelta c [i, j] que almacena el coeficiente de correlación para los observables cuánticos i-th y j-th.
Del mismo modo, el momento de covarianza se puede encontrar:

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

Números al azar

Una parte importante de cada simulación es la capacidad de generar números aleatorios. Para hacer esto, utilizamos el generador de números pseudoaleatorio incorporado en NumPy en el submódulo aleatorio. Los números son pseudoaleatorios , en el sentido de que se generan de manera determinista a partir de un número semilla, pero se dispersan aleatoriamente en similitudes estadísticas. Para generar NumPy utiliza un algoritmo especial llamado Mersenne Twister.
Puede especificar el elemento generador de una secuencia de números aleatorios de la siguiente manera:

 >>> np.random.seed(293423)

La semilla es un número entero. Cada programa que comienza con la misma semilla generará la misma secuencia de números cada vez. Esto puede ser útil para la depuración, pero en general no necesitamos establecer la semilla, de hecho, cuando ejecutamos el programa varias veces, queremos obtener una secuencia de números diferente cada vez. Si este comando no se ejecuta, NumPy selecciona automáticamente una semilla aleatoria (en función del tiempo), que es diferente cada vez que se inicia el programa.
Se puede generar una matriz de números aleatorios del medio intervalo [0.0, 1.0) de la siguiente manera:

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

La función rand se puede usar para generar matrices bidimensionales, o la función de remodelación se puede usar:

 >>> 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 generar un solo número aleatorio en el intervalo [0.0, 1.0):

 >>> np.random.random() 0.70110427435769551

Para generar un entero aleatorio en el rango [min, max), use la función randint (min, max):

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

En cada uno de nuestros ejemplos, generamos números a partir de una distribución uniforme continua. NumPy también incluye generadores para otras distribuciones, tales como: Beta, binomial, chi-cuadrado, Dirichlet, exponencial, Fischer, Gamma, geométrico, Gambal, hipergeométrico, Laplace, logístico, lognormal, logarítmico, multinomial, multidimensional normal, binomial negativo, no central. chi-cuadrado, Fischer descentrado, normal (Gauss), Pareto, Poisson, potencia, Rayleigh, Cauchy, estudiante, triangular, Von Mies, Wald, Weibull y Zipf. Veamos dos ejemplos.
Para generar a partir de una distribución discreta de Poisson en λ = 6.0,

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

Para generar un número a partir de la distribución normal (gaussiana) con un valor promedio de μ = 1.5 y desviación estándar σ = 4.0:

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

Para obtener un número de la distribución normal (μ = 0, σ = 1), sin especificar argumentos:

 >>> np.random.normal() 0.27548716940682932

Para generar múltiples valores, use el argumento de tamaño:

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

El módulo para generar números aleatorios también se puede utilizar para distribuir valores aleatoriamente en una lista. Esto puede ser útil si queremos distribuir valores al azar en una 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]

Tenga en cuenta que la función aleatoria modifica una matriz existente y no devuelve una nueva.

Alguna información adicional

NumPy incluye muchas más funciones que no hemos mencionado aquí. En particular, estas son funciones para trabajar con la transformada discreta de Fourier, operaciones más complejas en álgebra lineal, probar matrices para tamaño / dimensión / tipo, dividir y conectar matrices, histogramas, crear matrices a partir de cualquier información de diferentes maneras, crear y operar matrices de cuadrícula , con valores especiales (NaN, Inf), operaciones de conjuntos, la creación de diferentes tipos de matrices especiales y el cálculo de funciones matemáticas especiales (por ejemplo: funciones de Bessel). También puede ver la documentación de NumPy para obtener detalles más precisos.

Módulos de ciencia ficción

SciPy extiende la funcionalidad de NumPy muy bien. No hablaremos de sus detalles, pero consideremos algunas de sus posibilidades. La mayoría de las funciones de SciPy están disponibles después de importar el módulo:

 >>> import scipy

La función de ayuda proporciona información útil sobre 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)
...

Tenga en cuenta que algunos submódulos necesitan directamente una importación adicional, que están marcados con una estrella:

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

Las funciones en cada módulo están bien documentadas en cadenas de documentos internas y en documentación oficial. La mayoría de ellos proporcionan directamente funciones para trabajar con algoritmos numéricos y son muy fáciles de usar. Por lo tanto, SciPy puede ahorrar una cantidad gigantesca de tiempo en cálculos científicos, porque Proporciona funciones ya escritas y probadas.
No consideraremos SciPy en detalle, pero la tabla a continuación cubrirá algunas de sus características:

Modulo	Para qué se utiliza
scipy.constants	Conjunto de constantes matemáticas y físicas.
scipy.special	Muchas funciones especiales para la física matemática, tales como: Airy, elíptica, Bessel, gamma, beta, hipergeométrica, cilindro parabólico, Mathieu, onda esférica, Struve, Kelvin.
scipy.integrate	Funciones para trabajar con integración numérica utilizando los métodos de trapecio, Simpson, Romberg y otros. También proporciona métodos para trabajar con ecuaciones diferenciales completas.
scipy.optimize	Métodos estándar alto / bajo para trabajar con funciones de usuario genéricas. Algoritmos incluidos: Nelder - Mead, Pull ( Powell's ), gradientes conjugados, Bruden - Fletcher - Goldfarb - Channo, mínimos cuadrados, optimización condicional, recocido simulado, búsqueda exhaustiva, Brent, Newton, bisección, Broyden, Anderson y búsqueda lineal.
scipy.linalg	Funcionalidad más amplia para trabajar con álgebra lineal que en NumPy. Proporciona más opciones para usar funciones especiales y rápidas para objetos específicos (por ejemplo: una matriz de tres diagonales). Métodos incluidos: búsqueda de una matriz no degenerada, búsqueda de un determinante, solución de sistemas lineales de ecuaciones, cálculo de normas y una matriz pseudoinversa, descomposición espectral, descomposición singular, descomposición LU, descomposición Cholesky, descomposición QR, descomposición Schur y muchas otras operaciones matemáticas para trabajar con matrices.
scipy.sparse	Funciones para trabajar con matrices dispersas grandes
scipy.interpolate	Métodos y clases para interpolar objetos que se pueden usar para datos numéricos discretos. La interpolación lineal y spline ( Nota del traductor: representación matemática de curvas suaves ) está disponible para conjuntos de datos de una y dos dimensiones.
scipy.fftpack	Métodos para procesar transformadas de Fourier.
scipy.signal	Métodos para procesar señales, por ejemplo: convolución de funciones, correlación, transformada de Fourier discreta, suavizado de B-spline, filtrado, etc., etc.
scipy.stats	Una gran biblioteca de funciones estadísticas y distribuciones para trabajar con conjuntos de datos.

Un gran grupo de desarrolladores continúa desarrollando continuamente nuevas funciones de SciPy. Un buen enfoque práctico es este: si está pensando en implementar alguna función y método numérico en su código, primero puede consultar la documentación original de SciPy. Existe la posibilidad de que alguien ya haya implementado y contribuido a SciPy.

Epílogo

Nuestra serie de artículos ha llegado a su fin. Gracias a todos los que leyeron y se tomaron el tiempo. También espero que hayas traído información útil y hayas aprendido algo nuevo. ¡Continúa desarrollando y aprendiendo cosas nuevas! Hasta pronto.

NumPy en Python. Parte 4