Vectores en

Acerca de Vectores

Un objetivo central de Julia es poder realizar cálculos sobre datos numéricos de forma rápida y eficiente. Muchísimos datos numéricos.

Por lo general, los datos se almacenan en arrays (o en algún tipo relacionado), así que es razonable decir que los arrays están en el corazón del lenguaje Julia.

Los arrays pueden tener un tamaño arbitrario (limitado únicamente por las restricciones de memoria de tu hardware) y pueden tener cualquier número de dimensiones.

Algunos tipos de arrays tienen nombres especiales (copiados del Álgebra Lineal). Un array unidimensional se llama Vector, y un array bidimensional se llama Matrix. Ambos son subtipos de Array en Julia.

Este concepto introductorio se centra en los fundamentos de Vector. Los arrays de más dimensiones se tratarán más adelante en el temario.

Creación de vectores

En Julia, un Vector es una secuencia ordenada de valores a los que se puede acceder mediante un número de índice.

La forma más sencilla de crear un Vector es enumerar los valores entre corchetes:

julia> num_vec = [1, 4, 9]
3-element Vector{Int64}:
 1
 4
 9

julia> str_vec = ["arrays", "are", "important"]
3-element Vector{String}:
 "arrays"
 "are"
 "important"

El tipo Vector coincide con el tipo de cada elemento.

Técnicamente, es un vector columna, pero ignora eso por ahora si no estás familiarizado con el Álgebra Lineal. Tendrá más sentido después del concepto de Arrays multidimensionales.

¿Entonces los Vector tienen que ser homogéneos (todos los elementos del mismo tipo)?

En cierto sentido, sí, y se recomienda aspirar a ello si quieres obtener el mejor rendimiento. Sin embargo, Julia puede sortear esta limitación (cuando es necesario) usando el tipo Any:

julia> mixed_vector = [1, "str", 'c']
3-element Vector{Any}:
 1
  "str"
  'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)

Al crear un Vector vacío, Julia usa por defecto el tipo de elemento Any, pero se puede definir de forma más específica anotando el array vacío con el tipo de elemento deseado.

julia> empty_vec = []
Any[]

julia> empty_int_vec = Int64[]
Int64[]

Vectores preinicializados

Es muy común partir de vectores con todos los valores a 0 o a 1. Para ello existen las funciones llamadas (como era de esperar) zeros() y ones(), que toman el tamaño del vector como parámetro. El tipo por defecto es Float64, pero opcionalmente se pueden especificar otros tipos numéricos.

De forma análoga, la función fill() toma tanto un valor que repetir como el tamaño deseado del vector.

julia> zeros(3)
3-element Vector{Float64}:
 0.0
 0.0
 0.0

julia> ones(3)
3-element Vector{Float64}:
 1.0
 1.0
 1.0

julia> ones(Int64, 3)
3-element Vector{Int64}:
 1
 1
 1

julia> fill(42, 3)
3-element Vector{Int64}:
 42
 42
 42

Hay muchas otras opciones: consulta el manual.

Lee y recuerda esta regla:

• Por defecto, la indexación en Julia empieza en 1, no en 0.

Esto les resultará familiar a quienes hayan usado otros lenguajes de ciencia de datos (R, Matlab, Fortran...), pero puede parecer sorprendente a los informáticos con experiencia en lenguajes de estilo C.

Por lo demás, los índices funcionan como puedes imaginar: solo tienes que ponerlos entre corchetes:

squares = [0, 1, 4, 9, 16]
squares[1]  # 0
squares[3]  # 4
squares[begin]  # 0 ("begin" is synonym for 1)
squares[end]  # 16 ("end" is synonym for length(squares))

Fíjate en lo cómodo que resulta indexar con end (que es muy útil) y con begin (que probablemente no lo sea).

Quizá los programadores de Python se pregunten por los índices negativos. No lo hagas: no forman parte de Julia y lanzarán un BoundsError, igual que cualquier índice menor que 1 o mayor que length(squares).

Operaciones con vectores

Los Vector en Julia son mutables: podemos cambiar el contenido de celdas individuales.

julia> vals = [1, 3, 5, 7]
4-element Vector{Int64}:
 1
 3
 5
 7

julia> vals[2] = 4  # reassign the value of this element
4

# Only the value at position 2 changes:
julia> vals
4-element Vector{Int64}:
 1
 4
 5
 7

Hay muchas funciones disponibles para manipular vectores, aunque la documentación de Julia las generaliza a «colecciones» en lugar de vectores.

Ten en cuenta que, por convención, las funciones que mutan su entrada llevan un ! en el nombre. El compilador no lo impone, pero es una convención muy fuerte en el mundo de Julia.

Estas son algunas de las funciones útiles:

• Para añadir valores al final del vector, usa push!().
• Para eliminar el último valor, usa pop!().
• Para operar al principio del vector, las funciones correspondientes son pushfirst!() y popfirst!().
• Para insertar o eliminar un elemento en cualquier posición, están insert!() y deleteat!().

julia> vals = [1, 3]
2-element Vector{Int64}:
 1
 3

julia> push!(vals, 5, 6)  # can add multiple values
4-element Vector{Int64}:
 1
 3
 5
 6

julia> pop!(vals)  # mutates vals, return popped value
6

julia> vals
3-element Vector{Int64}:
 1
 3
 5

Concatenación

La concatenación es bastante sencilla para los vectores, aunque un vistazo al manual advierte de las complejidades que nos esperan cuando consideremos arrays multidimensionales.

La función append!() puede tomar como entrada una combinación de varios vectores y elementos sueltos.

julia> append!([1, 2], [3, 4], [-1, -2], 15)
7-element Vector{Int64}:
  1
  2
  3
  4
 -1
 -2
 15