Vectores en

Acerca de Vectores

Uno de los objetivos centrales de Julia es poder hacer cálculos con datos numéricos de forma rápida y eficiente. Muchísimos datos numéricos.

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

Los arrays pueden tener un tamaño arbitrario (limitado solo por la memoria de tu computadora) y pueden tener cualquier número de dimensiones.

Algunos tipos de arrays tienen nombres especiales (tomados 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 lo básico de los vectores. Los arrays con más dimensiones se verá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 por su 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 del vector coincide con el tipo de cada elemento.

Técnicamente, es un vector columna, pero ignora eso por ahora si el álgebra lineal no te resulta familiar. Debería tener más sentido después del concepto de arrays multidimensionales.

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

En cierto nivel, sí, y se recomienda apuntar a eso si quieres el mejor rendimiento. Sin embargo, Julia puede sortear esta limitación (cuando sea 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)

Cuando creas un vector vacío, Julia usa por defecto el tipo de elemento Any, pero puedes definirlo de forma más específica anotando el array vacío con el tipo de elemento que quieras.

julia> empty_vec = []
Any[]

julia> empty_int_vec = Int64[]
Int64[]

Vectores prellenados

Es muy común empezar con vectores que solo contienen 0 o solo contienen 1. Para eso existen 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 similar, la función fill() recibe tanto un valor que se repite 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 resulta familiar a quienes han usado otros lenguajes de ciencia de datos (R, Matlab, Fortran...), pero puede resultar chocante para quienes vienen de lenguajes tipo C.

Por lo demás, los índices funcionan como te imaginas: solo hay 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 es indexar con end (que es muy útil) y con begin (que probablemente no lo sea).

Quienes programan en Python quizá se pregunten por los índices negativos. No los hay: no forman parte de Julia y generarán un BoundsError, igual que cualquier índice menor que 1 o mayor que length(squares).

Operaciones con vectores

Los vectores 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.

Fíjate que, por convención, las funciones que mutan su entrada llevan ! 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 agregar valores al final del vector, usa push!().
• Para quitar el último valor, usa pop!().
• Para operar sobre el principio del vector, las funciones correspondientes son pushfirst!() y popfirst!().
• Para insertar o quitar 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 con los vectores, aunque un vistazo al manual advierte de las complejidades que nos esperan cuando lleguemos a los arrays multidimensionales.

La función append!() puede recibir como argumentos una mezcla 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