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

julia> arr = [1,2,3]
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

julia> arr =[1, "EJEMPLO", 2.5, pi]
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

julia> arr = Int64[1,2,3]
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

julia> arr = Int64[]
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

julia> arr = Int64[1,2,3]
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

julia> array = Array{Int64}(undef, 3)    # Indica un arreglo unidimensional, el arreglo tiene 3 elementos
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

julia> [1 2 3 4]
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

julia> [1 2; 3 4]
2×2 Matrix{Int64}:
 1  2
 3  4

También se pueden usar dos puntos:y espacios para lograrlo, mira el siguiente ejemplo:

Ejemplo

julia> [1:2  3:4]
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

julia> [[1,2] [3,4] [5,6]]
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

julia> [[1;2] [3;4] [5;6]]
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

julia> [0:10...]
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

julia> collect(1:2:13)
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

julia> collect(Float64, 1:2:5)
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

julia> range(1, length=100)
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

julia> collect(range(1,stop=10))
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

julia> [n^2 for n in 1:10]
10-element Vector{Int64}:
   1
   4
   9
  16
  25
  36
  49
  64
  81
 100

Crear un arreglo bidimensional:

Ejemplo

julia> [n*m for n in 1:10, m in 1:10]
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

julia> collect(n^2 for n in 1:5)
5-element Vector{Int64}:
  1
  4
  9
 16
 25

La siguiente expresión suma una secuencia sin asignar memoria:

Ejemplo

julia> sum(1/n^2 for n=1:1000)
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 es [ 0 , 1 ) [0, 1) distribució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

julia> zeros(Int8, 2, 3)
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
otras extensiones