RRPara 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
RPara 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
Rc()nrow o ncol, respectivamentebyrow para indicar si hemos escrito los números del vector por filas o por columnasRTambié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
RPara 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
RAdemá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.
RPara 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
RPara 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
RPara 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
RPara 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
RPara 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
RY, 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
RLa 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
RLa 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
RLas 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
RLa transpuesta de una matriz se consegue aplicando la función t()
M
[,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
RPara calcular la traza de la matriz (la suma de los elementos de la diagonal):
sum(diag(M))
[1] 2
RLa 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
REl producto de un esclalar por una matriz:
5*A
[,1] [,2] [,3] [1,] 5 10 15 [2,] 20 25 30 [3,] 35 40 45
REl 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
RFijaos 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
RPara 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
RPara 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
RPara 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
REl rango de una matriz se calcula con la función qr()$rank
qr(A)$rank
[1] 2
RLa 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
Rround(solve(M)%*%M)
[,1] [,2] [,3] [1,] 1 0 0 [2,] 0 1 0 [3,] 0 0 1
PythonPythonUtilizaremos 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]]
PythonPara crear una matriz,
M = [[1,2,3],[4,5,6],[7,8,9]] M
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
PythonPara llamar a un elemento, utilizamos la sintaxis siguiente:
M[1][1]
5
La primera posición indica la fila y, la segunda, la columna.
Python, al contrario que en R, las posiciones empiezan en 0.
M[0][0]
1
PythonPara llamar a una fila,
M[0]
[1, 2, 3]
PythonCambié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]]
PythonLa 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.]]
PythonPara llamar a un elemento, utilizamos la sintaxis mostrada anteriormente:
M = np.array([[1,2,3],[4,5,6],[7,8,9]]) M[0][2]
3
Para llamar a una fila,
print(M[1])
[4 5 6]
PythonTambién nos sirve la sintaxis
M[1,:]
array([4, 5, 6])
Para llamar a una columna,
M[:,0]
array([1, 4, 7])
PythonPara 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.]]
PythonPara 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.]]
PythonPara 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]])
PythonY para obtener la diagonal principal de una matriz, utilizamos de nuevo la función numpy.diag()
np.diag(N)
array([1, 2, 3, 4])
PythonPara saber la dimensión de una matriz, utilizamos la función np.shape():
np.shape(M)
(3, 3)
PythonSi queremos la suma de todos los elementos de una matriz:
np.sum(M)
45
PythonSi 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])
PythonSi queremos el producto de todos los elementos de una matriz:
np.prod(M)
362880
PythonSi 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.])
PythonPara calcular la transpuesta de una matriz, utilizamos la función .transpose():
print(M.transpose())
[[1 4 7] [2 5 8] [3 6 9]]
PythonPara calcular la traza de una matriz:
print(M.trace())
15
PythonSuma de matrices:
A = np.array([[1,2],[2,0]]) B = np.array([[3,0],[1,4]]) print(A+B)
[[4 2] [3 4]]
PythonEl producto de un escalar por una matriz:
print(5*A)
[[ 5 10] [10 0]]
PythonProducto 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]]
PythonPara calcular la potencia de una matriz:
print(np.linalg.matrix_power(A,5))
[[65 58] [58 36]]
PythonPara calcular el rango de una matriz, utilizamos np.linalg.matrix_rank()
np.linalg.matrix_rank(A)
2
np.linalg.matrix_rank(B)
2
PythonPara 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.]]
OctaveOctavePara 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
OctaveEntonces, para crear una matriz:
M = [1 2 3; 4 5 6; 7 8 9]
M = 1 2 3 4 5 6 7 8 9
OctavePara 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
OctavePara llamar a una columna
M = [1 2 3; 4 5 6; 7 8 9]; M(:,3)
ans = 3 6 9
OctavePara 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
OctavePara 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
OctavePara 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
OctavePara 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
OctavePara obtener la diagonal principal de una matriz:
N = diag([1 2 3 4 5]); diagonal = diag(N)
diagonal = 1 2 3 4 5
OctavePara 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
OctavePara sumar todos los elementos de una matriz:
M = [1 2 3; 4 5 6; 7 8 9]; suma = sum(sum(M))
suma = 45
OctavePara 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
OctavePara 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
OctavePara multiplicar los elementos de una matriz:
M = [1 2 3; 4 5 6; 7 8 9]; producto = prod(prod(M))
producto = 362880
OctavePara calcular la media los elementos de una matriz:
M = [1 2 3; 4 5 6; 7 8 9]; media = mean(mean(M))
media = 5
OctavePara 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
OctavePara 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
OctaveO bien
M = [1 2 3; 4 5 6; 7 8 9]; mediaCol = mean(M,1)
mediaCol = 4 5 6
OctavePara calcular la transpuesta de una matriz, utilizamos el apostrofe, '
M = [1 2 3; 4 5 6; 7 8 9]; M'
ans = 1 4 7 2 5 8 3 6 9
OctavePara 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
OctaveSuma de matrices:
A = [1 -1; 0 3]; B = [2 1; -1 0]; A+B
ans = 3 0 -1 3
OctaveProducto de un escalar por una matriz:
A = [1 -1; 0 3]; 2*A
ans = 2 -2 0 6
OctaveProducto de matrices:
A = [1 -1; 0 3]; B = [2 1; -1 0]; A*B
ans = 3 1 -3 0
OctavePotencia 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
OctavePara 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
OctavePara 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