Minicurso de Python para Matemáticas

4 Elementos de la computación matricial 4.1 NumPy array 5 Gráficos

Ayuda a mantener el sitio libre, gratuito y sin publicidad. ¡Colabora!

4.2 Elementos del álgebra lineal

El numpy cuenta con un módulo de álgebra lineal, usualmente importado con

1import numpy.linalg as npla

4.2.1 Vectores

Un vector puede asignarse usando un numpy.array de un eje (dimensión). Por ejemplo,

	$\displaystyle x=(2,-1),$		(4.12)
	$\displaystyle y=(3,1,\pi)$		(4.13)

podem ser alocados com

⬇

1x = np.array([2,-1])

2print(x)

[ 2 -1]

⬇

1y = np.array([3, 1, np.pi])

2print(y)

[3. 1. 3.14159265]

Ejercicio 4.2.1.1.

Asigne cada uno de los siguientes vectores como un numpy.array:

a)

$x=(1.2,-3.1,4)$
c)

$z=(\pi,\sqrt{2},e^{-2})$

⬇

1import numpy as np

2# a)

3x = np.array([1.2, -3.1, 4])

4print('x = ', x)

5# b)

6z = np.array([np.pi, np.sqrt(2.), np.exp(-2)])

7print('z = ', z)

4.2.2 Producto escalar y norma

Dados dos vectores

	$\displaystyle x=(x_{0},x_{1},\dotsc,x_{n-1}),$		(4.14)
	$\displaystyle y=(y_{0},y_{1},\dotsc,y_{n-1}),$		(4.15)

define-se el producto escalar por

x\cdot y=x_{0}y_{0}+x_{1}y_{1}+\cdots+x_{n-1}y_{n-1}.

(4.16)

Con el NumPy, podemos calcularlo con la función numpy.dot. Por ejemplo,

⬇

1x = np.array([-1, 0, 2])

2y = np.array([0, 1, 1])

3d = np.dot(x,y)

4print(d)

La norma $l_{2}$ de un vector se define por

\|x\|_{2}=\sqrt{\sum_{i=0}^{n-1}x_{i}^{2}}.

(4.17)

El NumPy cuenta con el método numpy.linalg.norm para calcularla. Por ejemplo,

⬇

1nrm = npla.norm(y)

2print(nrm)

4.457533443631058

Ejercicio 4.2.2.1.

Haga un código para calcular el producto escalar $x\cdot y$ siendo

	$\displaystyle x=(1.2,\ln(2),4),$		(4.18)
	$\displaystyle y=(\pi^{2},\sqrt{3},e)$		(4.19)

⬇

1import numpy as np

2x = np.array([1.2, np.log(2), 4])

3y = np.array([np.pi**2, np.sqrt(3), np.e])

4d = np.dot(x,y)

4.2.3 Matrices

Una matriz puede asignarse como un numpy.array de dos ejes (dimensiones). Por ejemplo, las matrices

	$\displaystyle A=\begin{bmatrix}2&-1&7\\ 3&1&0\end{bmatrix},$		(4.20)
	$\displaystyle B=\begin{bmatrix}4&0\\ 2&1\\ -8&6\end{bmatrix}$		(4.21)

podem ser alocadas como segue

⬇

1A = np.array([[2,-1,7],

2 [3,1,0]])

3print(A)

[[ 2 -1 7]

[ 3 1 0]]

⬇

1B = np.array([[4,0],

2 [2,1],

3 [-8,6]])

4print(B)

[[ 4 0]

[ 2 1]

[-8 6]]

Como ya hemos visto, el NumPy cuenta con operadores elemento-a-elemento que pueden utilizarse en el álgebra involucrando arrays, luego también aplicables a matrices (consulte la Subsección 4.1.3). A continuación, vamos a introducir otras operaciones propias de este tipo de objeto.

Ejercicio 4.2.3.1.

Asigne cada una de las siguientes matrices como un numpy.array:

a)

$A=\begin{bmatrix}-1&2\\ 2&-4\\ 6&0\end{bmatrix}$ (4.22)
b)

$B=A^{T}$

⬇

1import numpy as np

2A = np.array([[-1, 2],

3 [2, -4],

4 [6, 0]])

5# b)

6B = A.transpose()

Ejercicio 4.2.3.2.

Sea

⬇

1A = np.array([[2,1],[1,1],[-3,-2]])

Determine el formato (shape) de los siguientes arrays:

a)

A[:,0]
b)

A[:,0:1]
c)

A[1:3,0]
d)

A[1:3,0:1]
e)

A[1:3,0:2]

⬇

1import numpy as np

2# a)

3A = np.array([[2, 1],

4 [1, 1],

5 [-3, -2]])

6print('a)', A[:,0].shape)

7print('b)', A[:,0:1].shape)

8print('c)', A[1:3,0].shape)

9print('d)', A[1:3,0:1].shape)

10print('e)', A[1:3,0:2].shape)

4.2.4 Inicialización de matrices

Además de las inicializaciones de arrays ya estudiadas en la Subsección 4.1.1, tenemos algunas más que son particularmente útiles en el caso de matrices.

numpy.eye(n): retorna la matriz identidad $n\times n$ .

⬇

1I = np.eye(3)

2print(I)

⬇

[[1. 0. 0.],

[0. 1. 0.],

[0. 0. 1.]]
numpy.diag: extrae la diagonal o construye un numpy.array diagonal.

⬇

1D = np.diag([1,2,3])

2print(D)

⬇

[[1, 0, 0],

[0, 2, 0],

[0, 0, 3]]

Ejercicio 4.2.4.1.

Asigne la matriz de los coeficientes y el vector de los términos constantes del siguiente sistema de ecuaciones

	$\displaystyle x_{1}=0$		(4.23)
	$\displaystyle-x_{i-1}+2x_{i}-x_{i+1}=h^{2}f_{i}$		(4.24)
	$\displaystyle x_{n}=0$		(4.25)

donde $f_{i}=\pi^{2}\sin(\pi x_{i})$ , $x_{i}=(i-1)h$ , $h=1/(n-1)$ , n=5.

⬇

1import numpy as np

2n = 5

3h = 1./(n-1)

4x = np.linspace(0., 1., n)

5b = np.pi**2*np.sin(np.pi*x)

6A = np.diag(2*np.ones(n)) + \

7 np.diag(-np.ones(n-1), k=-1) + \

8 np.diag(-np.ones(n-1), k=1)

9A[0,0] = 1.

10A[0,1] = 0.

11A[n-1,n-2] = 0.

12A[n-1,n-1] = 1.

13print('A = \n', A)

14print('b = \n', b)

4.2.5 Multiplicación de matrices

La multiplicación de la matriz $A=[a_{ij}]_{i,j=0}^{n-1,l-1}$ por la matriz $B=[b_{ij}]_{i,j=0}^{l-1,m-1}$ es la matriz $C=AB=[c_{ij}]_{i,j=0}^{n-1,m-1}$ tal que

c_{ij}=\sum_{k=0}^{l-1}a_{ik}b_{k,j}

(4.26)

El numpy tiene la función numpy.matmul para calcular la multiplicación de matrices. Por ejemplo, la multiplicación de las matrices dadas en (4.20) y (4.21), calculamos

⬇

1C = np.matmul(A,B)

2print(C)

[[-50 41],

[ 14 1]]

Observación 4.2.5.1.(matmul, *, @)

Es importante notar que numpy.matmul(A,B) es la multiplicación de matrices, mientras que * consiste en la multiplicación elemento a elemento. Alternativamente a numpy.matmul(A,B) puede-se usar A @ B.

Ejercicio 4.2.5.1.

Asigne las matrices

	$\displaystyle C=\begin{bmatrix}1&2&-1\\ 3&2&1\\ 0&-2&-3\end{bmatrix}$		(4.27)
	$\displaystyle D=\begin{bmatrix}2&3\\ 1&-1\\ 6&4\end{bmatrix}$		(4.28)
	$\displaystyle E=\begin{bmatrix}1&2&1\\ 0&-1&3\end{bmatrix}$		(4.29)

Entonces, si existen, calcule y proporcione las dimensiones de las siguientes matrices

a)

$C D$
b)

$D^{T}E$
c)

$D^{T}C$
d)

$D E$

⬇

1import numpy as np

2C = np.array([[1, 2, -1],

3 [3, 2, 1],

4 [0, -2, -3]])

5D = np.array([[2, 3],

6 [1, -1],

7 [6, 4]])

8E = np.array([[1, 2, 1],

9 [0, -1, 3]])

10print('a) CD = \n', C@D)

11print("no existe D'E")

12print("c) D'C = \n", C.T@C)

13print("d) DE = \n", D@E)

4.2.6 Traza y determinante de una matriz

El numpy tiene la función numpy.ndarray.trace para calcular la traza de una matriz (suma de los elementos de su diagonal). Por ejemplo,

⬇

1A = np.array([[-1,2,0],[2,3,1],[1,2,-3]])

2print('tr(A) = ', A.trace())

tr(A) = -1

Ya, el determinante es proporcionado en el módulo numpy.linalg. Por ejemplo,

⬇

1A = np.array([[-1,2,0],[2,3,1],[1,2,-3]])

2print('det(A) = ', npla.det(A))

det(A) = 25.000000000000007

Ejercicio 4.2.6.1.

Calcule la solución del siguiente sistema de ecuaciones

	$\displaystyle x_{1}-x_{2}+x_{3}=-2$		(4.30)
	$\displaystyle 2x_{1}+2x_{2}+x_{3}=5$		(4.31)
	$\displaystyle-x_{1}-x_{2}+2x_{3}=-5$		(4.32)

por el método de Cramer⁵⁵5Gabriel Cramer, 1704 - 1752, matemático suizo. Fuente: Wikipedia: Gabriel Cramer..

⬇

1import numpy as np

2import numpy.linalg as npla

3# matriz de coefs

4A = np.array([[1, -1, 1],

5 [2, 2, 1],

6 [-1, -1, 2]])

7# vector de términos constantes

8b = np.array([-2, 5, -5])

9# mat aux A1

10A1 = A.copy()

11A1[:,0] = b

12# sol x1

13x1 = npla.det(A1)/npla.det(A)

14print('x1 = ', x1)

15# mat aux A2

16A2 = A.copy()

17A2[:,1] = b

18# sol x2

19x2 = npla.det(A2)/npla.det(A)

20print('x2 = ', x2)

21# mat aux A3

22A3 = A.copy()

23A3[:,2] = b

24# sol x3

25x3 = npla.det(A3)/npla.det(A)

26print('x3 = ', x3)

4.2.7 Rango e inversa de una matriz

El rango (rank) de una matriz es el número de filas o columnas linealmente independientes. El numpy cuenta con la función numpy.linalg.matrix_rank para calcularla. Por ejemplo,

⬇

1npla.matrix_rank(np.eye(3))

⬇

1A = np.array([[1,2,3],[-1,1,-1],[0,3,2]])

2npla.matrix_rank(A)

El método numpy.linalg.inv puede usarse para calcular la inversa de una matriz full rank. Por ejemplo,

⬇

1A = np.array([[1, 2, 3],

2 [-1, 1, -1],

3 [1, 3, 2]])

4Ainv = np.linalg.inv(A)

5print('Ainv @ A = \n', Ainv @ A)

Ainv @ A =

[[ 1.00000000e+00 -2.22044605e-16 -8.88178420e-16]

[ 0.00000000e+00 1.00000000e+00 0.00000000e+00]

[ 0.00000000e+00 -2.22044605e-16 1.00000000e+00]]

Ejercicio 4.2.7.1.

Calcule, si es posible, la matriz inversa de cada una de las siguientes matrices

	$\displaystyle B=\begin{bmatrix}2&-1\\ -2&1\end{bmatrix}$		(4.33)
	$\displaystyle C=\begin{bmatrix}-2&0&1\\ 3&1&-1\\ 2&1&0\end{bmatrix}$		(4.34)

Verifique sus respuestas.

⬇

1import numpy as np

2import numpy.linalg as npla

4def inv(A):

5 if (npla.matrix_rank(A) == A.shape[1]):

6 return npla.inv(A)

7 else:

8 print('Matriz no invertible.')

9 return None

11B = np.array([[2, -1],

12 [-2, 1]])

13print('inv(B) = \n', inv(B))

15A = np.array([[-2, 0, 1],

16 [3, 1, -1],

17 [2, 1, 0]])

18print('inv(A) = \n', inv(A))

4.2.8 Autovalores y autovectores de una Matriz

Un auto-par $(\lambda,v)$ de una matriz $A$ , $\lambda$ un escalar llamado autovalor y $v\neq 0$ es un vector llamado autovector, es tal que

A\lambda=\lambda v.

(4.35)

El numpy tiene la función numpy.linalg.eig para calcular los auto-pares de una matriz. Por ejemplo,

⬇

1lmbda, v = npla.eig(np.eye(3))

2print('autovalores = \n', lmbda)

3print('autovetores = \n', v)

autovalores =

[1. 1. 1.]

autovetores =

[[1. 0. 0.]

[0. 1. 0.]

[0. 0. 1.]]

Observamos que la función retorna un tuple de numpy.arrays, siendo que el primero contiene los autovalores (repetidos conforme sus multiplicidades) y el segundo ítem es la matriz de los autovectores (dispuestos en las columnas).

Ejercicio 4.2.8.1.

Calcule los auto-pares de la matriz

A=\begin{bmatrix}1&3&2\\ 3&2&-1\\ 2&-1&1\end{bmatrix}.

(4.36)

Entonces, verifique si, de hecho, $Av=\lambda v$ para cada auto-par $(\lambda,v)$ calculado.

⬇

1import numpy as np

2import numpy.linalg as npla

3A = np.array([[1, 3, 2],

4 [3, 2, -1],

5 [2, -1, 1]])

6lmbda, v = np.linalg.eig(A)

7# probando los auto-pares

8print(npla.norm(A @ v[:, 0] - lmbda[0] * v[:, 0]) < 1e-10)

9print(npla.norm(A @ v[:, 1] - lmbda[1] * v[:, 1]) < 1e-10)

10print(npla.norm(A @ v[:, 2] - lmbda[2] * v[:, 2]) < 1e-10)

Envía tu comentario

Aprovecho para agradecer a todas/os que de forma asidua o esporádica contribuyen enviando correcciones, sugerencias y críticas.

Este texto se publica bajo los términos de la Licencia Creative Commons Atribución-CompartirIgual 4.0 Internacional. Los íconos y elementos gráficos pueden estar sujetos a condiciones adicionales.

Política de uso de datos

Política de uso de datos

Minicurso de Python para Matemáticas

4.2 Elementos del álgebra lineal

4.2.1 Vectores

Ejercicio 4.2.1.1.

4.2.2 Producto escalar y norma

Ejercicio 4.2.2.1.

4.2.3 Matrices

Ejercicio 4.2.3.1.

Ejercicio 4.2.3.2.

4.2.4 Inicialización de matrices

Ejercicio 4.2.4.1.

4.2.5 Multiplicación de matrices

Observación 4.2.5.1.(matmul, *, @)

Ejercicio 4.2.5.1.

4.2.6 Traza y determinante de una matriz

Ejercicio 4.2.6.1.

4.2.7 Rango e inversa de una matriz

Ejercicio 4.2.7.1.

4.2.8 Autovalores y autovectores de una Matriz

Ejercicio 4.2.8.1.

Envía tu comentario