Arreglos en Julia
Un arreglo es una colección de elementos del mismo tipo de datos ordenados en una secuencia determinada; puede ser un arreglo unidimensional o multidimensional.
Julia admite estructuras de datos de arreglos, que pueden almacenar una colección ordenada de tamaño no fijo, donde los tipos pueden ser iguales o diferentes.
Los arreglos de Julia son colecciones de tipo mutable, utilizados para listas, vectores, tablas y matrices.
Los índices de los arreglos de Julia se pueden representar con números enteros, y el tamaño del arreglo no es fijo.
Julia proporciona muchas funciones para ayudarnos a manipular arreglos, como agregar elementos, combinar arreglos, etc.
Los arreglos en Julia se especifican con corchetes[...]para especificarlos, y múltiples elementos se separan con comas,separados.
La sintaxis para crear un arreglo unidimensional (es decir, un vector) es:
[A, B, C, ...]
Crear un arreglo unidimensional
El siguiente ejemplo crea un arreglo unidimensional simple:
Ejemplo
3-element Vector{Int64}:
1
2
3
En el ejemplo anterior creamos un arreglo unidimensional con 3 elementos, cada elemento es un entero de 64 bits; este arreglo unidimensional se vincula a la variablearr.
Los tipos de los elementos del arreglo también pueden ser diferentes:
Ejemplo
4-element Vector{Any}:
1
"EJEMPLO"
2.5
π = 3.1415926535897...
En el ejemplo anterior creamos un arreglo unidimensional de 4 elementos con diferentes tipos,pies una constanteπcada elemento es un entero de 64 bits; este arreglo unidimensional se vincula a la variablearr.
Por supuesto, también se puede forzar el tipo:
Ejemplo
3-element Vector{Int64}:
1
2
3
julia> arr2 = String["Taobao","EJEMPLO","GOOGLE"]
3-element Vector{String}:
"Taobao"
"EJEMPLO"
"GOOGLE"
En el ejemplo anterior, el arregloarrestá restringido a solo enteros,arr2está restringido a solo cadenas.
También podemos crear un arreglo vacío:
Ejemplo
Int64[]
julia> arr2 = String[]
String[]
El arreglo creado se puede acceder directamente usando valores de índice; el primer valor tiene índice 1 (no 0), el segundo valor índice 2, y así sucesivamente; el último se puede representar conendpara representarlo:
Ejemplo
3-element Vector{Int64}:
1
2
3
julia> arr[2]
2
julia> arr2 = String["Taobao","EJEMPLO","GOOGLE"]
3-element Vector{String}:
"Taobao"
"EJEMPLO"
"GOOGLE"
julia> arr2[1]
"Taobao"
julia> arr2[end]
"GOOGLE"
Especificar tipo y dimensiones del arreglo
También podemos usar la siguiente sintaxis para especificar el tipo y las dimensiones del arreglo:
Array{type}(undef, dims...)
undefIndica que el arreglo no está inicializado.
dims...Puede ser una tupla simple o múltiple de dimensiones, o un conjunto de valores cuando las dimensiones se pasan como argumentos variables.
dims...Un número indica la cantidad de elementos; para múltiples dimensiones se usan comas,para separarlas.
Ejemplo
3-element Vector{Int64}:
4834342704
4377305096
0
julia> array = Array{Int64}(undef, 3, 3, 3) # Indica un arreglo tridimensional, cada dimensión tiene 3 elementos
3×3×3 Array{Int64, 3}:
[:, :, 1] =
4562265712 0 0
1 0 0
0 0 0
[:, :, 2] =
0 0 0
0 0 0
0 0 0
[:, :, 3] =
0 0 0
0 0 0
0 0 0
En el ejemplo anterior, colocamos el tipo del arreglo entre llaves{}, undef se utiliza para configurar el arreglo sin inicializar con ningún valor conocido; por eso obtenemos números aleatorios en la salida.
Crear arreglos bidimensionales y matrices
Podemos omitir las comas entre los elementos del arreglo,o usar dos puntos;;, y así podemos crear un arreglo bidimensional, como en el siguiente ejemplo:
Ejemplo
1×4 Matrix{Int64}:
1 2 3 4
julia> [1;; 2;; 3;; 4]
1×4 Matrix{Int64}:
1 2 3 4
Nota:La primera línea de salida1×4 Matrix{Int64}:, 1x4 indica una matriz de una fila y cuatro columnas.
Aunque solo tiene una fila, sigue siendo un arreglo bidimensional, porque Julia solo reconoce vectores columna y no reconoce los llamados vectores fila.
Para agregar otra fila, solo necesitas agregar un punto y coma;, mira el siguiente ejemplo:
Ejemplo
2×2 Matrix{Int64}:
1 2
3 4
También se pueden usar dos puntos:y espacios para lograrlo, mira el siguiente ejemplo:
Ejemplo
2×2 Matrix{Int64}:
1 3
2 4
Nota:La primera línea de salida2×2 Matrix{Int64}:, 2×2 indica una matriz de dos filas y dos columnas.
También podemos, entre corchetes[]insertar múltiples arreglos unidimensionales de la misma longitud y separarlos con espacios para crear un arreglo bidimensional:
Ejemplo
2×3 Matrix{Int64}:
1 3 5
2 4 6
2x3Representa un arreglo de dos filas y tres columnas.
A continuación, mediante el uso flexible de punto y coma;y espacios creamos un arreglo bidimensional de dos filas y tres columnas, y otro de tres filas y dos columnas:
Ejemplo
2×3 Matrix{Int64}:
1 3 5
2 4 6
julia> [[1 2]; [3 4]; [5 6]]
3×2 Matrix{Int64}:
1 2
3 4
5 6
Usar funciones de rango para crear arreglos
Puntos suspensivos ...
Se pueden usar puntos suspensivos...para crear un arreglo, como en el siguiente ejemplo:
Ejemplo
11-element Vector{Int64}:
0
1
2
3
4
5
6
7
8
9
10
La función collect()
La sintaxis de la función collect() es la siguiente:
collect(start:step:stop)
start es el valor inicial, step es el tamaño del paso, stop es el valor final.
Esta función devuelve un arreglo.
En el siguiente ejemplo, el valor inicial es 1, el paso es 2 y el valor final es 13:
Ejemplo
7-element Vector{Int64}:
1
3
5
7
9
11
13
La función collect() también puede especificar el tipo; su sintaxis es la siguiente:
collect(element_type, start:step:stop)
El siguiente ejemplo crea un arreglo de tipo flotante:
Ejemplo
3-element Vector{Float64}:
1.0
3.0
5.0
La función range()
La función range() puede generar un intervalo de rango y especificar el paso, lo que facilita la llamada a la función collect().
La sintaxis de la función range() es la siguiente:
range(start, stop, length) range(start, stop; length, step) range(start; length, stop, step) range(;start, length, stop, step)start es el valor inicial, step es el tamaño del paso, stop es el valor final, length es la longitud.
Ejemplo
1:100
julia> range(1, stop=100)
1:100
julia> range(1, step=5, length=100)
1:5:496
julia> range(1, step=5, stop=100)
1:5:96
julia> range(1, 10, length=101)
1.0:0.09:10.0
julia> range(1, 100, step=5)
1:5:96
julia> range(stop=10, length=5)
6:10
julia> range(stop=10, step=1, length=5)
6:1:10
julia> range(start=1, step=1, stop=10)
1:1:10
Si no se especifica la longitud length, ystop - startstop no es un múltiplo entero de step, se generará un rango que termina antes de stop.
julia> range(1, 3.5, step=2) 1.0:2.0:3.0
Crear un arreglo usando range() y collect():
Ejemplo
10-element Vector{Int64}:
1
2
3
4
5
6
7
8
9
10
julia> collect(range(1, length=15, stop=150))
15-element Vector{Float64}:
1.0
11.642857142857142
22.285714285714285
32.92857142857143
43.57142857142857
54.214285714285715
64.85714285714286
75.5
86.14285714285714
96.78571428571429
107.42857142857143
118.07142857142857
128.71428571428572
139.35714285714286
150.0
Crear arreglos usando comprensiones y generadores
Otra forma útil de crear arreglos es usar comprensiones.
La sintaxis de la comprensión de arreglos es la siguiente:
A = [ F(x,y,...) for x=rx, y=ry, ... ]
F(x,y,...) toma cada valor de las variables x, y, etc., en la lista dada para calcular. Los valores pueden especificarse como cualquier objeto iterable, pero generalmente son rangos como 1:n o 2:(n-1), o valores de arreglo explícitos como [1.2, 3.4, 5.7]. El resultado es un arreglo denso N-dimensional, cuyas dimensiones se obtienen concatenando las dimensiones de los rangos de variables rx, ry, etc., y cada cálculo de F(x,y,...) devuelve un escalar.
Ejemplo
10-element Vector{Int64}:
1
4
9
16
25
36
49
64
81
100
Crear un arreglo bidimensional:
Ejemplo
10×10 Matrix{Int64}:
1 2 3 4 5 6 7 8 9 10
2 4 6 8 10 12 14 16 18 20
3 6 9 12 15 18 21 24 27 30
4 8 12 16 20 24 28 32 36 40
5 10 15 20 25 30 35 40 45 50
6 12 18 24 30 36 42 48 54 60
7 14 21 28 35 42 49 56 63 70
8 16 24 32 40 48 56 64 72 80
9 18 27 36 45 54 63 72 81 90
10 20 30 40 50 60 70 80 90 100
También se puede escribir la comprensión (de arreglo) sin corchetes, lo que produce un objeto llamado generador.
El siguiente ejemplo crea un arreglo:
Ejemplo
5-element Vector{Int64}:
1
4
9
16
25
La siguiente expresión suma una secuencia sin asignar memoria:
Ejemplo
1.6439345666815615
Funciones básicas de arreglos en Julia
| Función | Descripción |
|---|---|
eltype(A) |
ATipo de los elementos en |
length(A) |
ANúmero de elementos en |
ndims(A) |
ANúmero de dimensiones de |
size(A) |
Una tupla que contieneAel número de elementos en cada dimensión |
size(A,n) |
AordinalnNúmero de elementos en la dimensión |
axes(A) |
Una tupla que contieneAlos índices válidos |
axes(A,n) |
ordinalnEl rango de índices válidos en la dimensión |
eachindex(A) |
Un iterador eficiente para acceder aAcada posición en el arreglo |
stride(A,k) |
En lakdimensión, el stride (distancia de índice lineal entre elementos adyacentes) |
strides(A) |
Una tupla que contiene el stride en cada dimensión |
Construcción e inicialización en Julia
Julia proporciona muchas funciones para construir e inicializar arreglos. En las siguientes funciones, el argumento dims ... puede ser una tupla para indicar las dimensiones, o un valor entero de longitud variable como dimensiones. El primer argumento de la mayoría de las funciones indica el tipo de elemento T del arreglo. Si se omite el tipo T, se utilizará Float64 por defecto.
| Función | Descripción |
|---|---|
Array{T}(undef, dims...) |
Un arreglo denso no inicializadoArray |
zeros(T, dims...) |
Un arreglo de cerosArray |
ones(T, dims...) |
Un arreglo con todos los elementos iguales a 1Array |
trues(dims...) |
Un arreglo donde cada elemento estruedeBitArray |
falses(dims...) |
un donde cada elemento esfalsedeBitArray |
reshape(A, dims...) |
uno que contiene conAarray con los mismos datos pero con dimensiones diferentes |
copy(A) |
copiaA |
deepcopy(A) |
copia profunda, es decir, copiaA, y copia recursivamente sus elementos |
similar(A, T, dims...) |
uno conAun array no inicializado que tiene el mismo tipo (aquí se refiere a denso, disperso, etc.), pero con el tipo de elemento y las dimensiones especificados. El segundo y el tercer parámetro son opcionales; si se omiten, se establecen por defecto en el tipo de elemento yAde las dimensiones. |
reinterpret(T, A) |
yAun array con los mismos datos binarios, pero el tipo de elemento esT |
rand(T, dims...) |
una aleatoriaArray, el valor del elemento esdistribución uniforme en un intervalo semiabierto y que sigue una distribución de primer orden independiente e idénticamente distribuida[1] |
randn(T, dims...) |
una aleatoriaArray, los elementos siguen una distribución normal estándar, independiente e idénticamente distribuida |
Matrix{T}(I, m, n) |
mLíneanmatriz identidad de columnas (es necesario ejecutar primerousing LinearAlgebrapara poder usarI) |
range(start, stop=stop, length=n) |
desdestartllegarstopque tienenel rango de elementos espaciados linealmente |
fill!(A, x) |
con el valorxrellenar el arrayA |
fill(x, dims...) |
uno por el valorxrellenadoArray |
zeros()crear una instancia de array, los valores iniciales de los elementos son todos 0:
Ejemplo
2×3 Matrix{Int8}:
0 0 0
0 0 0
julia> zeros(Int8, (2, 3))
2×3 Matrix{Int8}:
0 0 0
0 0 0
julia> zeros((2, 3))
2×3 Matrix{Float64}:
0.0 0.0 0.0
0.0 0.0 0.0