• Author / Uploaded
• Victor Alvarado

• Categories
• Estructura de datos de matriz
• Valores propios y vectores propios
• Matriz (Matemáticas)
• Álgebra
• Física y matemáticas

Citation preview

9/6/2016

4.1. Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas

http://pendientedemigracion.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html

1/4

9/6/2016

4.1. Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas

El desarrollo y la principal finalidad del módulo Numpy es la creación y modificación de arrays multidimensionales. Para este fin utilizaremos las clase ndarray del ingles Ndimensional array o usando su alias simplemente array (no confundir con la clase array.array que ofrece menos funcionalidad). En Python cada clase puede tener atributos que se pueden llamar con el método visto anteriormente o simplemente escribiendo a continuación de la clase un punto y el atributo. En la mayoría de los IDEs al cargar la clase y escribir el punto aparecen todos los atributos disponibles en orden alfabético por lo que en caso de dudar siempre podemos utilizar este método para escribir el comando. En el caso de ndarray los principales atributos son los siguientes: ndarray.ndim –> Proporciona el número de dimensiones de nuestro array. El array identidad es un array cuadrado con una diagonal principal unitaria. ndarray.shape –> Devuelve la dimensión del array, es decir, una tupla de enteros indicando el tamaño del array en cada dimensión. Para una matriz de n filas y m columnas obtendremos (n,m). ndarray.size –> Es el número total de elementos del array. ndarray.dtype –> Es un objeto que describe el tipo de elementos del array. ndarray.itemsize –> devuelve el tamaño del array en bytes. ndarray.data –> El buffer contiene los elementos actuales del array. Veamos un ejemplo de su uso con un array sencillo de diez elementos,

Ejemplo 4.4 >>> import numpy as np # Importamos numpy como el alias np >>> miArray = np.arange(10) # Creamos un array de 0 a 9 separados de uno en uno >>> miArray # Presentamos en pantalla el array creado array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) >>> type(miArray) #Comprobamos que es un ndarray

>>> miArray.ndim

# Consultamos el número de dimensiones

1 >>> miArray.shape # Consultamos la dimensión (10,) >>> miArray.size # Consultamos la dimensión 10 >>> miArray.dtype # Consultamos el tipo de elementos del array dtype('int64') >>> miArray.itemsize # tamaño en bytes 8 >>> miArray.data # Consultamos el buffer de memoria.

Como hemos mencionando anteriormente, los arrays son unos de los elementos más utilizados por los programadores bajo cualquier lenguaje. Este gran uso hace que dispongamos de una gran variedad de comandos para la creación de arrays: arrays unidimensionales, multidimensionales, nulos, unitarios, secuenciales, de números aleatorios, etc. Dependiendo de las necesidades de nuestro problema escogeremos la opción más adecuada. identity(n,dtype). Devuelve la matriz identidad, es decir, uma matriz cuadrada nula excepto en su diagonal principal que es unitaria. n es el número de filas (y columnas) que tendrá la matriz y dtype es el tipo de dato. Este argumento es opcional. Si no se establece, se toma por defecto como flotante. ones(shape,dtype). Crea un array de unos compuesto de shape elementos. zeros(shape, dtype). Crea un array de ceros compuesto de “shape” elementos”. empty(shape, dtype). Crea un array de ceros compuesto de “shape” elementos” sin entradas. eye(N, M, k, dtype). Crea un array bidimensional con unos en la diagonal k y ceros en el resto. Es similar a identity. Todos los argumentos son opcionales. N es el número de filas, M el de columnas y k es el índice de la diagonal. Cuando k=0 nos referimos a la diagonal principal y por tanto eye es similar a identity. arange([start,]stop[,step,],dtype=None). Crea un array con valores distanciados step entre el valor inicial star y el valor final stop. Si no se establece step python establecerá uno por defecto. linspace(start,stop,num,endpoint=True,retstep=False). Crea un array con valor inicial start, valor final stop y num elementos. meshgrid(x,y). Genera una matriz de coordenadas a partir de dos los arrays x, y. En el siguiente ejemplo podemos ver su utilización,

Ejemplo 4.5 >>> from numpy import * # Importamos todo el módulo numpy. >>> zeros( (3,4) )

# Creamos un array nulo de 3 filas y 4 columnas.

array([[0., 0., 0., 0.],

[0., 0., 0., 0.],

[0., 0., 0., 0.]]) >>> ones(9)

# Creamos un array unitario de 1 fila y 9 columnas,

array([ 1., 1., 1., 1., 1., 1., 1., 1., 1.]) >>> empty( (2,3) )

# Creamos un array sin entradas de 2x3.

array([[ 3.73603959e‐262, 6.02658058e‐154, 6.55490914e‐260],

http://pendientedemigracion.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html

2/4

9/6/2016

4.1. Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas

[ 5.30498948e‐313, 3.14673309e‐307, 1.00000000e+000]]) >>> arange( 10, 30, 5 ) # Creamos un array con inicio en 10 final en 30 y paso de 5. array([10, 15, 20, 25]) >>> linspace( 0, 2, 9 )

# Array de 9 elementos de 0 a 2 array([ 0. ,

0.25, 0.5 , 0.75, 1. , 1.25, 1.5 , 1.75, 2. ]) >>> x = linspace( 0, 2*pi, 100 )

# Para gráficas conviene tener muchos puntos, en este caso 100 puntos entre 0 y 2*pi.

>>> X, Y = np.meshgrid([1,2,3], [4,5,6,7]) # Generamos una matriz de coordenadas. >>> X array([[1, 2, 3],

[1, 2,

3], [1, 2, 3], [1, 2, 3]]) >>> Y array([[4, 4, 4],

[5, 5,

5], [6, 6, 6],

[7, 7,

7]])

4.1.3. Matrices Un subtipo especial de array bidimensional de NumPy es la matriz. Una matriz es como una array, excepto que la multiplicación de matrices (y exponenciación) reemplaza la multiplicación elemento a elemento. Las matrices se crean mediante la función matrix.

Ejemplo 4.6 >>> from numpy import matrix # Importamos matrix del módulo numpy. >>>

a

=

matrix([[1,3,‐5],[3,4,2],[‐5,2,0]])

matrix([[ 1, 3, ‐5],

[ 3, 4, 2],

[‐5, 2, 0]]) >>> b = matrix([[1],[5],[3]]) >>> b matrix([[1], [5], [3]]) >>> a*b matrix([[ 1], [29], [ 5]])

Definidas las matrices, podemos hacer uso de todas las funciones relacionadas con el álgebra lineal como la transposición, la diagonalización etc.

Ejemplo 4.7 >>> b.T

# Calculamos la transpuesta de *b*. matrix([[1, 5, 3]])

>>> b.H

# Calculamos la hermítica (transpuesta y conjugada) de *b*. matrix([[1, 5, 3]])

>>> c = a.I

# Calculamos la inversa de *b*.

>>> c matrix([[ 0.02439024, 0.15853659],

0.06097561,

[ 0.06097561,

‐

0.15243902,

0.10365854], [‐0.15853659, 0.10365854, 0.0304878 ]]) >>> a*c

# Multiplicamos las matrices *a* y *c*.

matrix([[ 1.00000000e+00, ‐5.55111512e‐17, ‐6.93889390e‐18], [ 0.00000000e+00, 1.00000000e+00, 4.16333634e‐17], [ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00]])

Con el paquete linalg podemos calcular el determinante (det), resolver ecuaciones lineales (solve) y calcular autovalores y autovectores.

Ejemplo 4.8 >>> linalg.det(a)

# Cálculo del determinante.

‐164.0 >>> d = linalg.solve(a,b)

# Resolución de ecuaciones lineales.

>>> d matrix([[‐0.14634146], [ 1.13414634], [ 0.45121951]])

http://pendientedemigracion.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html

3/4

9/6/2016

4.1. Numpy — Computación científica con Python para módulos de evaluación continua en asignaturas de ciencias aplicadas

>>> a*d matrix([[ 1.], [ 5.], [ 3.]]) >>> e = linalg.eig(a)

# Cálculo de autovalores y autovectores.

>>> e[0] array([‐5.78304165, 6.23396835, 4.5490733 ]) >>> e[1] matrix([[ 0.65072855, ‐0.7001856 , ‐0.29375583],

[‐

0.33849942, ‐0.61380708, 0.71320335], [ 0.67968412, 0.3646656 , 0.6364342 ]]) >>> u = e[1] >>> u.T*a*u matrix([[ ‐5.78304165e+00, ‐ 1.22688318e‐15, ‐7.92985469e‐16],

[ ‐1.62554432e‐15,

6.23396835e+00, 1.43223107e‐15], [ ‐7.68916181e‐16, 1.83533744e‐15, 4.54907330e+00]])

La función eig devuelve una tupla donde el primer elemento es un array de autovalores y el segundo es una matriz que contiene a los autovectores.

4.1.4. Operaciones y funciones El módulo numpy contiene todas las operaciones usuales entre arrays como las matemáticas (suma, resta, multiplicación, etc), las lógicas (and, or, xor, etc), binarias, ... Lo más fácil y sencillo es en caso de duda consultar la documentación oficial. De particular interés en óptica es la transformada de Fourier,

Ejemplo 4.9 >>> import numpy as np # Importamos numpy como el alias np. >>> x=np.linspace(0,1,16) >>> y=np.sin(x) >>> print np.fft.fft(y) array([ 6.82834723+0.j

, ‐0.72886897+1.98380961j,

‐0.46469805+0.9337634j , ‐0.42166285+0.57663662j, ‐0.40711196+0.38478538j, ‐0.40066563+0.25695308j, ‐0.39747563+0.15924205j, ‐0.39594637+0.07645992j, ‐0.39548834+0.j

, ‐0.39594637‐0.07645992j,

‐0.39747563‐0.15924205j, ‐0.40066563‐0.25695308j, ‐0.40711196‐0.38478538j, ‐0.42166285‐0.57663662j, ‐0.46469805‐0.9337634j , ‐0.72886897‐1.98380961j])

obsérvese como se ha formado en número complejo 2j. En python los números complejos se forman (parte real signo jparte imaginaria), es decir, separando parte real e imaginaria y sin ningún signo multiplicativo entre el coeficiente y el numero imaginario j.

Ejemplo 4.10 >>> numero_complejo = (1 + 1j) # Defino el número complejo. >>> print(numero_complejo)

# Lo presento en pantalla.

(1+1j) >>> type(numero_complejo)

# Compruebo el tipo.

complex

ANTERIOR | SIGUIENTE MOSTRAR EL CÓDIGO © Copyright 2013, Luis Miguel Sánchez Brea. Creado con Sphinx

http://pendientedemigracion.ucm.es/info/aocg/python/modulos_cientificos/numpy/index.html

4/4