5 Funciones

Julia y los paquetes que amplían sus capacidades proveen muchas funciones para realizar operaciones matemáticas y analizar datos. Para ordenar la discusión, categorizamos dichas funciones en matriciales, vectoriales y escalares.

Aquí presentamos sólo algunos ejemplos de las funciones que les serán más útiles.

5.1 Funciones Escalares

Las funciones escalares aplican operaciones sobre escalares. Son utilizables en escalares, vectores y matrices (y en general en cualquier Arreglo multidimensional). En el caso de los dos primeros, la operaciones se realizan elemento por elemento.

Algunos ejemplos:

sin, cos: Seno, Coseno
exp, log, log10, abs: Exponencial, logaritmo natural, logaritmo base 10 Valor absoluto
sign: Signo (1 para positivo, -1 para negativo, 0 para cero)
round, ceil, floor: Redondea a entero

a = 2
expa = exp(a)

7.38905609893065

cosa = cos(a)

-0.4161468365471424

loga = log(a)

0.6931471805599453

b = -2.2
absa = abs(b)

2.2

Para aplicar funciones escalares a vectores y matrices usamos la construcción funcion.(), indicando así que la operación será realizada con cada elemento escalar que compone el vector o la matriz. Por ejemplo, usando un vector:

B = [2, 3]
expB = exp.(B)

2-element Array{Float64,1}:
  7.38905609893065 
 20.085536923187668

Ahora usando una matriz:

C = rand(2,2)
logC = log.(C)

2×2 Array{Float64,2}:
 -1.75642   -2.47962
 -0.244705  -1.8672

Otras funciones escalares útiles son:

round(1.6)

2.0

ceil(1.2)

2.0

floor(1.2)

1.0

sign(-4)

-1

5.2 Funciones Vectoriales

Las funciones vectoriales aplican operaciones sobre vectores. Son utilizables en vectores y matrices. En el caso de las segundas, las operaciones se aplican por fila o por columna.

Algunos ejemplos:

maximum, minimum, findmax, findmin: Máximo, mínimo.
length: Tamaño de un vector
sort, sortrows: Ordenar vector, ordenar filas de una matriz
sum, prod, cumsum, cumprod: Suma, producto, suma acumulada, producto acumulado
mean, std, median, var, cov: Media, desviación estándar, mediana, varianza, covarianza (para estas funciones se usa el paquete Statistics que viene en la instalación Base de Julia).

Ejemplo:

v = rand(6,1) # Generamos un vector

6×1 Array{Float64,2}:
 0.5714666579881484 
 0.41454651823739486
 0.7423252568236218 
 0.8653171543587022 
 0.21238998257389796
 0.3723851947176551

vmax = maximum(v)

0.8653171543587022

vmin = minimum(v)

0.21238998257389796

length(v)

Las funciones vectoriales, según la operación que realicen tienen diversas opciones y posiblemente entregan más de un resultado. Ver opciones de cada función usando ?funcion.

Ejemplo de uso de funciones con más de un argumento de la función:

G = rand(5,3)

5×3 Array{Float64,2}:
 0.468011  0.190221   0.878875
 0.777597  0.458129   0.956853
 0.963205  0.0919655  0.606627
 0.247977  0.149666   0.196096
 0.90866   0.900251   0.445866

a = maximum(G)

0.935572586895675

Note que la función maximum() encuentra el máximo dentro de todos los elementos. Si nos interesa buscar el máximo por filas o por columnas utilizamos la opción dims:

a = maximum(G, dims=1) # Máximo por columnas

1×3 Array{Float64,2}:
 0.907517  0.935573  0.910205

a = maximum(G, dims=2) # Máximo por filas

5×1 Array{Float64,2}:
 0.8190659153938897 
 0.33200993069149387
 0.5656425924230455 
 0.910205063785412  
 0.935572586895675

Esta misma lógica aplica a funciones como sum(), prod(), cumsum() y cumprod() (en el caso de los dos últimos la dimensión es un argumento obligatorio). Ejemplo:

G_suma_asum = cumsum(G, dims=1) # Acumula suma por columnas

5×3 Array{Float64,2}:
 0.819066  0.413214  0.619649
 1.15108   0.728593  0.880318
 1.68734   0.812171  1.44596 
 2.59486   1.43562   2.35617 
 3.2942    2.37119   2.68509

Las funciones findmax y findmin son ejemplos de funciones que tienen más de un resultado. En este caso, el valor del máximo (mínimo) y la posición del mismo. Ejemplo:

minval, posind = findmax(G)

(0.963204864575407, CartesianIndex(3, 1))

Lo que indica que el máximo de \(G\) es 0.96 y la posición dentro la matriz es fila 3 y columna 1. Para acceder a la fila y columna de posind usamos el índice ordinal:

posind[1]

posind[2]

Cuando definimos la orientación fila o columna, findmax entregara el valor y la posición en cada fila o columna.

minval, posind = findmax(G,dims=1)

([0.963205 0.900251 0.956853], CartesianIndex{2}[CartesianIndex(3, 1) CartesianIndex(5, 2) CartesianIndex(2, 3)])

posind[1]

CartesianIndex(3, 1)

Note que usamos indexación para acceder a cada posición. Para para acceder al valor fila o columna de la fila o columna correspondiente usamos doble indexación:

posind[1][1] # Posición max en primera columna (fila,col). Además posición fila dentro esa columna.

Las funciones estadísticas como mean, std, median, var y cov, entre otras, son fundamentales en el análisis de datos. Para usarlas en Julia necesitamos primero cargar el paquete Statistics que viene en la instalación base de Julia.

using Statistics

mGc = mean(G)  # promedio de todos los elementos de la matriz.

0.5493332362365936

mGf = mean(G,dims=1) # promedios por columnas

1×3 Array{Float64,2}:
 0.67309  0.358046  0.616863

mGf = mean(G,dims=2)  # promedios por filas

5×1 Array{Float64,2}:
 0.5123689853589612 
 0.7308597059953457 
 0.5539325353975396 
 0.19791281818954234
 0.7515921362415785

mGc = std(G) # desvío estándar, todos los elementos

0.32653109009181447

mGf = mean(G,dims=1) # desvío estándar por columnas

1×3 Array{Float64,2}:
 0.67309  0.358046  0.616863

Para calcular covarianzas a partir de dos vectores usamos:

a = rand(5,1)
b = rand(5,1)
covab = cov(a,b)

1×1 Array{Float64,2}:
 0.015762767459558256

5.3 Funciones Matriciales

La funciones matriciales realizan operaciones sobre matrices y sólo son utilizables con este tipo de objetos.

Algunos ejemplos:

size: Tamaño de la matriz.
inv: Inversa (es mejor utilizar /).
eig: Autovalores y autovectores.
cholesky: Descomposición de Cholesky
det: Determinante.
kron: Producto de kronecker.
: Convierte un matriz en un vector columna: vectorizar A[:].
reshape(A,filas,columnas): Cambio de dimensión.
diag: Diagonal de una matriz (además matriz diagonal si el argumento es un vector).
triu, tril: Matrices triangulares, superior e inferior.

Para contar con la funcionalidad del álgebra lineal debemos cargar el paquete LinearAlgebra:

using LinearAlgebra

Creamos una matriz \(3 \times 3\) con números aleatorios para generar ejemplo sobre las funciones matriciales:

G = rand(3,3)

3×3 Array{Float64,2}:
 0.854378  0.357735    0.320768
 0.751719  0.00107406  0.06885 
 0.945119  0.46043     0.597043

El determinante de la matriz:

det_matriz = det(G)

-0.05311570062090768

La inversa de la matriz:

inv(G)

3×3 Array{Float64,2}:
  0.584749   1.24053  -0.457219
  7.22456   -3.89595  -3.4322  
 -6.49712    1.04074   5.04556

Los elementos de la diagonal principal son:

diag(G)

3-element Array{Float64,1}:
 0.854378426292786  
 0.00107406348726502
 0.5970430661012691

Para construir una matriz diagonal a partir de un vector usamos diagm() con la opción 0 => para indicar que el vector poblará la diagonal principal:

diagm(0 => collect(1:4))

4×4 Array{Int64,2}:
 1  0  0  0
 0  2  0  0
 0  0  3  0
 0  0  0  4

Para vectorizar una matriz usamos [:] o reshape(A,numfilas,1) (el primer caso convierte la matriz en un Arreglo de una dimensión, mientras que el segundo convierte la matriz en un vector fila/columna dependiendo de las dimensiones):

vecG = G[:]

9-element Array{Float64,1}:
 0.854378426292786  
 0.7517194056123091 
 0.9451193092573495 
 0.3577347741422632 
 0.00107406348726502
 0.46043031649101995
 0.3207684393106236 
 0.06884996935714605
 0.5970430661012691

vecG = reshape(G,9,1)

9×1 Array{Float64,2}:
 0.854378426292786  
 0.7517194056123091 
 0.9451193092573495 
 0.3577347741422632 
 0.00107406348726502
 0.46043031649101995
 0.3207684393106236 
 0.06884996935714605
 0.5970430661012691

Calculamos los autovalores y autovectores de una matriz usando eigen():

eigenval, eigenvecs = eigen(G)

Eigen{Float64,Float64,Array{Float64,2},Array{Float64,1}}
eigenvalues:
3-element Array{Float64,1}:
  1.4903935251619282 
  0.17078180535293447
 -0.2086797746335427 
eigenvectors:
3×3 Array{Float64,2}:
 -0.563894  -0.180407   0.237944
 -0.319819  -0.442791  -0.936864
 -0.761406   0.878288   0.25626

eigenval

3-element Array{Float64,1}:
  1.4903935251619282 
  0.17078180535293447
 -0.2086797746335427

eigenvecs

3×3 Array{Float64,2}:
 -0.563894  -0.180407   0.237944
 -0.319819  -0.442791  -0.936864
 -0.761406   0.878288   0.25626

Obtenemos matrices triangulares a partir de una matriz usando triu() (superior) y tril() (inferior):

F = ones(4,4)
tril(F)

4×4 Array{Float64,2}:
 1.0  0.0  0.0  0.0
 1.0  1.0  0.0  0.0
 1.0  1.0  1.0  0.0
 1.0  1.0  1.0  1.0

triu(F)

4×4 Array{Float64,2}:
 1.0  1.0  1.0  1.0
 0.0  1.0  1.0  1.0
 0.0  0.0  1.0  1.0
 0.0  0.0  0.0  1.0

Para crear una matriz de tamaño \(4 \times 4\) y rellenarla del valor 5.0 usamos fill():

H = fill(5.0, (4,4))

4×4 Array{Float64,2}:
 5.0  5.0  5.0  5.0
 5.0  5.0  5.0  5.0
 5.0  5.0  5.0  5.0
 5.0  5.0  5.0  5.0

Finalmente, podemos transformar vectores en matrices usando reshape():

v = collect(1:1:9)

9-element Array{Int64,1}:
 1
 2
 3
 4
 5
 6
 7
 8
 9

R = reshape(v,3,3)

3×3 Array{Int64,2}:
 1  4  7
 2  5  8
 3  6  9