Matrices con R, Python y Octave

1.10 Matrices con `R`

Para crear una matriz fila,

row = matrix(c(1,2,3,4), nrow = 1)
row

     [,1] [,2] [,3] [,4]
[1,]    1    2    3    4

Para crear una matriz columna,

col = matrix(c(1,2,3), ncol = 1)
col

     [,1]
[1,]    1
[2,]    2
[3,]    3

Para crear matrices se utiliza la instrucción matrix()

A = matrix(c(1,1,3,5,2,4,3,-2,-2,2,-1,3), nrow = 3, ncol = 4, byrow = TRUE)
A

     [,1] [,2] [,3] [,4]
[1,]    1    1    3    5
[2,]    2    4    3   -2
[3,]   -2    2   -1    3

B = matrix(c(1,0,2,3,3,2,1,-2,3), nrow = 3, byrow = FALSE)
B

     [,1] [,2] [,3]
[1,]    1    3    1
[2,]    0    3   -2
[3,]    2    2    3

Los datos de la matriz deben ir en un vector c()
Hay que indicar el número de filas y/o columnas con nrow o ncol, respectivamente
Debemos utilizar el parámetro lógico byrow para indicar si hemos escrito los números del vector por filas o por columnas

También podemos crear matrices con las funciones bind()

C = rbind(c(1,2,3),c(4,5,6),c(7,8,9))
C

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    4    5    6
[3,]    7    8    9

D = cbind(c(1,2,3),c(4,5,6),c(7,8,9))
D

     [,1] [,2] [,3]
[1,]    1    4    7
[2,]    2    5    8
[3,]    3    6    9

Para acceder a un elemento/fila/columna de una matriz se sigue la sintaxis A[i,j], donde $i$ indica la fila y $j$, la columna

A[3,3] #Elemento a33

[1] -1

A[1,] #Primera fila

[1] 1 1 3 5

B[,2] #Segunda columna

[1] 3 3 2

Observación. Tal y como podemos ver en la anterior diapositiva, si dejamos el parámetro de las filas vacío, estamos llamando a todas las filas. Lo mismo ocurre con las columnas si dejamos ese parámetro vacío.

Además, no necesariamente tiene por qué ser simplemente un número lo introducido por parámetro, también puede ser un vector de posiciones con el cual llamar a varias filas o columnas a la vez según pertoque.

Para crear una matriz de ceros,

O = matrix(0, nrow = 3, ncol = 3)
O

     [,1] [,2] [,3]
[1,]    0    0    0
[2,]    0    0    0
[3,]    0    0    0

Para crear una matriz de unos,

ones = matrix(1, nrow = 3, ncol = 3)
ones

     [,1] [,2] [,3]
[1,]    1    1    1
[2,]    1    1    1
[3,]    1    1    1

Para crear una matriz diagonal, utilizamos la función diag()

E = diag(c(1,2,3,4,5,6))
E

     [,1] [,2] [,3] [,4] [,5] [,6]
[1,]    1    0    0    0    0    0
[2,]    0    2    0    0    0    0
[3,]    0    0    3    0    0    0
[4,]    0    0    0    4    0    0
[5,]    0    0    0    0    5    0
[6,]    0    0    0    0    0    6

Para obtener los elementos de la diagonal de una matriz, utilizamos la función diag() introduciendo por parámetro la matriz pertinente:

M = rbind(c(1,0,1),c(2,-1,5),c(3,3,2))
diag(M)

[1]  1 -1  2

Para obtener el número de filas o columnas de una matriz, utilizamos las funciones nrow() o ncol(), respectivamente:

nrow(M)

[1] 3

ncol(M)

[1] 3

Y, si queremos la dimensión de la matriz, utilizamos la función dim(), la cual nos devuelve un vector de dos entradas: el primero, el número de filas y, el segundo, el de columnas:

dim(M)

[1] 3 3

La función sum() aplicada a una matriz calcula la suma de todos los elementos de dicha matriz:

sum(M)

[1] 16

Las sumas por filas o por columnas se calculan del siguiente modo

rowSums(M) #sumas por filas

[1] 2 6 8

colSums(M) #sumas por columnas

[1] 6 2 8

La función prod() aplicada a una matriz calcula el producto de todos los elementos de dicha matriz:

prod(M)

[1] 0

La función mean() aplicada a una matriz calcula la media (aritmética) de todos los elementos de dicha matriz:

mean(M)

[1] 1.777778

Las medias por filas o por columnas se calculan del siguiente modo

rowMeans(M) #sumas por filas

[1] 0.6666667 2.0000000 2.6666667

colMeans(M) #sumas por columnas

[1] 2.0000000 0.6666667 2.6666667

La transpuesta de una matriz se consegue aplicando la función t()

     [,1] [,2] [,3]
[1,]    1    0    1
[2,]    2   -1    5
[3,]    3    3    2

t(M)

     [,1] [,2] [,3]
[1,]    1    2    3
[2,]    0   -1    3
[3,]    1    5    2

Para calcular la traza de la matriz (la suma de los elementos de la diagonal):

sum(diag(M))

[1] 2

La suma de matrices:

A = rbind(c(1,2,3),c(4,5,6),c(7,8,9))
B = rbind(c(1,0,2),c(3,0,4),c(5,0,6))
A+B

     [,1] [,2] [,3]
[1,]    2    2    5
[2,]    7    5   10
[3,]   12    8   15

B+A

     [,1] [,2] [,3]
[1,]    2    2    5
[2,]    7    5   10
[3,]   12    8   15

El producto de un esclalar por una matriz:

5*A

     [,1] [,2] [,3]
[1,]    5   10   15
[2,]   20   25   30
[3,]   35   40   45

El producto de matrices:

A%*%B

     [,1] [,2] [,3]
[1,]   22    0   28
[2,]   49    0   64
[3,]   76    0  100

B%*%A

     [,1] [,2] [,3]
[1,]   15   18   21
[2,]   31   38   45
[3,]   47   58   69

Fijaos que el producto de matrices se consigue aplicando %*% y no *.

En el segundo caso, lo que hace R es devolver como resultado una matriz $C = (c_{ij})$ cuyos elementos son $c_{ij}=a_{ij}\cdot b_{ij}$.

A*B

     [,1] [,2] [,3]
[1,]    1    0    6
[2,]   12    0   24
[3,]   35    0   54

Para comprobar que dos matrices son iguales, utilizamos el operador lógico ==

A+B == B+A

     [,1] [,2] [,3]
[1,] TRUE TRUE TRUE
[2,] TRUE TRUE TRUE
[3,] TRUE TRUE TRUE

A%*%B == B%*%A

      [,1]  [,2]  [,3]
[1,] FALSE FALSE FALSE
[2,] FALSE FALSE FALSE
[3,] FALSE FALSE FALSE

Con que haya un FALSE, sabemos que son diferentes

Para calcular la potencia $n$-ésima (aproximada) de una matriz, utilizamos la función mtx.exp(), del paquete Biodem

mtx.exp(A,4)

      [,1]  [,2]  [,3]
[1,]  7560  9288 11016
[2,] 17118 21033 24948
[3,] 26676 32778 38880

Para calcular la potencia $n$-ésima (aproximada) de una matriz, utilizamos %^%, del paquete expm

A%^%4

      [,1]  [,2]  [,3]
[1,]  7560  9288 11016
[2,] 17118 21033 24948
[3,] 26676 32778 38880

El rango de una matriz se calcula con la función qr()$rank

qr(A)$rank

[1] 2

La inversa (aproximada) de una matriz (invertible) se calcula mediante la función solve()

solve(M)

       [,1]   [,2]   [,3]
[1,]  2.125 -0.375 -0.125
[2,] -1.375  0.125  0.375
[3,] -1.125  0.375  0.125

round(M%*%solve(M))

     [,1] [,2] [,3]
[1,]    1    0    0
[2,]    0    1    0
[3,]    0    0    1

round(solve(M)%*%M)

     [,1] [,2] [,3]
[1,]    1    0    0
[2,]    0    1    0
[3,]    0    0    1

1.11 Matrices con `Python`

Utilizaremos la librería numpy. Para crear una matriz fila,

row = [1,2,3]
row

[1, 2, 3]

Para crear una matriz columna,

col = [[1],[2],[3]]
col

[[1], [2], [3]]

Para crear una matriz,

M = [[1,2,3],[4,5,6],[7,8,9]]
M

[[1, 2, 3], [4, 5, 6], [7, 8, 9]]

Para llamar a un elemento, utilizamos la sintaxis siguiente:

M[1][1]

La primera posición indica la fila y, la segunda, la columna.

Observación. En Python, al contrario que en R, las posiciones empiezan en 0.

M[0][0]

Para llamar a una fila,

M[0]

[1, 2, 3]

Cambiémosle la sintaxis a la matriz, para poder trabajar correctamente con ella:

import numpy as np
M = np.array([[1,2,3],[4,5,6],[7,8,9]])
print(M)

[[1 2 3]
 [4 5 6]
 [7 8 9]]

La función np.array() tiene un parámetro, dtype, en el cual podemos indicar el tipo de dato de la matriz: int, float, complex…

M = np.array([[1,2,3],[4,5,6],[7,8,9]], dtype = complex)
print(M)

[[1.+0.j 2.+0.j 3.+0.j]
 [4.+0.j 5.+0.j 6.+0.j]
 [7.+0.j 8.+0.j 9.+0.j]]

M = np.array([[1,2,3],[4,5,6],[7,8,9]], dtype = float)
print(M)

[[1. 2. 3.]
 [4. 5. 6.]
 [7. 8. 9.]]

Para llamar a un elemento, utilizamos la sintaxis mostrada anteriormente:

M = np.array([[1,2,3],[4,5,6],[7,8,9]])
M[0][2]

Para llamar a una fila,

print(M[1])

[4 5 6]

También nos sirve la sintaxis

M[1,:]

array([4, 5, 6])

Para llamar a una columna,

M[:,0]

array([1, 4, 7])

Para crear una matriz de ceros, utilizamos la función np.zeros((fil,col)):

print(np.zeros((5,7)))

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

Para crear una matriz de unos, utilizamos la función np.ones((fil,col)):

print(np.ones((5,10)))

[[1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]
 [1. 1. 1. 1. 1. 1. 1. 1. 1. 1.]]

Para crear una matriz diagonal hacemos lo siguiente:

x = [1,2,3,4]
N = np.diag(x)
N

array([[1, 0, 0, 0],
       [0, 2, 0, 0],
       [0, 0, 3, 0],
       [0, 0, 0, 4]])

Y para obtener la diagonal principal de una matriz, utilizamos de nuevo la función numpy.diag()

np.diag(N)

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

Para saber la dimensión de una matriz, utilizamos la función np.shape():

np.shape(M)

(3, 3)

Si queremos la suma de todos los elementos de una matriz:

np.sum(M)

Si queremos la suma por filas

np.sum(M, axis = 0)

array([12, 15, 18])

Si queremos la suma por columnas

np.sum(M, axis = 1)

array([ 6, 15, 24])

Si queremos el producto de todos los elementos de una matriz:

np.prod(M)

Si queremos la media aritmética de todos los elementos de una matriz:

np.mean(M)

5.0

Si queremos la media aritmética por filas o columnas:

np.mean(M, axis = 0) #Por filas

array([4., 5., 6.])

np.mean(M, axis = 1) #Por columnas

array([2., 5., 8.])

Para calcular la transpuesta de una matriz, utilizamos la función .transpose():

print(M.transpose())

[[1 4 7]
 [2 5 8]
 [3 6 9]]

Para calcular la traza de una matriz:

print(M.trace())

Suma de matrices:

A = np.array([[1,2],[2,0]])
B = np.array([[3,0],[1,4]])
print(A+B)

[[4 2]
 [3 4]]

El producto de un escalar por una matriz:

print(5*A)

[[ 5 10]
 [10  0]]

Producto de matrices:

print(A.dot(B))

[[5 8]
 [6 0]]

Observad que si utilizáis la sintaxis A*B, se multiplican elemento a elemento, como ocurría en R.

print(A*B)

[[3 0]
 [2 0]]

Para calcular la potencia de una matriz:

print(np.linalg.matrix_power(A,5))

[[65 58]
 [58 36]]

Para calcular el rango de una matriz, utilizamos np.linalg.matrix_rank()

np.linalg.matrix_rank(A)

np.linalg.matrix_rank(B)

Para calcular la inversa:

print(np.linalg.inv(A))

[[ 0.    0.5 ]
 [ 0.5  -0.25]]

print(np.linalg.inv(A).dot(A))#Comprobamos

[[1. 0.]
 [0. 1.]]

1.12 Matrices con `Octave`

Para crear una matriz fila,

row = [1 2 3]

row =

   1   2   3

Para crear una matriz columna,

col = [1;2;3]

Entonces, para crear una matriz:

M = [1 2 3; 4 5 6; 7 8 9]

Para llamar a un elemento, utilizamos la sintaxis

M = [1 2 3; 4 5 6; 7 8 9];
M(1,1)

ans =  1

Para llamar a una fila,

M = [1 2 3; 4 5 6; 7 8 9];
M(2,:)

ans =

   4   5   6

Para llamar a una columna

M = [1 2 3; 4 5 6; 7 8 9];
M(:,3)

Para saber el tipo de una matriz, lo que hacemos es utilizar la función matrix_type()

M = [1 2 3; 4 5 6; 7 8 9];
matrix_type(M)
N = [1 0 0; 0 1 0; 0 0 9];
matrix_type(N)

ans = Full
ans = Upper

Para crear una matriz de ceros, utilizamos la función repmat(0,m,n) donde $m$ son el número de filas y $n$ el de columnas:

O = repmat(0,5,8)

O =

   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0
   0   0   0   0   0   0   0   0

Para crear una matriz de unos, utilizamos una sintaxis similar a la anterior:

ones = repmat(1,3,7)

ones =

   1   1   1   1   1   1   1
   1   1   1   1   1   1   1
   1   1   1   1   1   1   1

Para crear una matriz diagonal:

N = diag([1 2 3 4 5])

N =

Diagonal Matrix

   1   0   0   0   0
   0   2   0   0   0
   0   0   3   0   0
   0   0   0   4   0
   0   0   0   0   5

Para obtener la diagonal principal de una matriz:

N = diag([1 2 3 4 5]);
diagonal = diag(N)

diagonal =

   1
   2
   3
   4
   5

Para saber la dimensión de una matriz, hacemos uso de la función size()

M = [1 2 3; 4 5 6; 7 8 9];
size(M)

ans =

   3   3

Para sumar todos los elementos de una matriz:

M = [1 2 3; 4 5 6; 7 8 9];
suma = sum(sum(M))

suma =  45

Para sumar los elementos de una matriz por filas:

M = [1 2 3; 4 5 6; 7 8 9];
sumaFil = sum(M,2)

sumaFil =

    6
   15
   24

Para sumar los elementos de una matriz por columnas, basta simplemente

M = [1 2 3; 4 5 6; 7 8 9];
sumaCol = sum(M)

sumaCol =

   12   15   18

o bien

M = [1 2 3; 4 5 6; 7 8 9];
sumaCol = sum(M, 1)

sumaCol =

   12   15   18

Para multiplicar los elementos de una matriz:

M = [1 2 3; 4 5 6; 7 8 9];
producto = prod(prod(M))

producto =  362880

Para calcular la media los elementos de una matriz:

M = [1 2 3; 4 5 6; 7 8 9];
media = mean(mean(M))

media =  5

Para calcular la media los elementos de una matriz por filas

M = [1 2 3; 4 5 6; 7 8 9];
mediaFil = mean(M,2)

mediaFil =

   2
   5
   8

Para calcular la media los elementos de una matriz por columnas basta simplemente

M = [1 2 3; 4 5 6; 7 8 9];
mediaCol = mean(M)

mediaCol =

   4   5   6

O bien

M = [1 2 3; 4 5 6; 7 8 9];
mediaCol = mean(M,1)

mediaCol =

   4   5   6

Para calcular la transpuesta de una matriz, utilizamos el apostrofe, '

M = [1 2 3; 4 5 6; 7 8 9];
M'

Para calcular la traza de una matriz, utilizamos la función trace():

A = [1 -1; 0 3];
B = [2 1; -1 0];
trace(A)
trace(B)

ans =  4
ans =  2

Suma de matrices:

A = [1 -1; 0 3];
B = [2 1; -1 0];
A+B

ans =

   3   0
  -1   3

Producto de un escalar por una matriz:

A = [1 -1; 0 3];
2*A

ans =

   2  -2
   0   6

Producto de matrices:

A = [1 -1; 0 3];
B = [2 1; -1 0];
A*B

ans =

   3   1
  -3   0

Potencia de matrices:

A = [1 -1; 0 3];
B = [2 1; -1 0];
A^3
B^4

ans =

    1  -13
    0   27

ans =

   5   4
  -4  -3

Para calcular el rango de una matriz, utilizamos la función rank():

A = [1 -1; 0 3];
B = [2 1; -1 0];
rank(A)
rank(B)

ans =  2
ans =  2

Para calcular la inversa de una matriz, hacemos uso de la función inv()

A = [1 -1; 0 3];
B = [2 1; -1 0];
inv(A)
inv(A)*A

ans =

   1.00000   0.33333
   0.00000   0.33333

ans =

   1.00000  -0.00000
   0.00000   1.00000

Matrices con R, Python y Octave

1.10 Matrices con R

1.11 Matrices con Python

1.12 Matrices con Octave

1.10 Matrices con `R`

1.11 Matrices con `Python`

1.12 Matrices con `Octave`