Arrays en Julia

Los arreglos en Julia son una colección de elementos al igual que otras colecciones como Conjuntos, Diccionarios, etc. Los arreglos son diferentes de los Conjuntos porque los arreglos son colecciones ordenadas de elementos y pueden contener valores duplicados, a diferencia de los conjuntos que requieren que todos los elementos sean únicos. Los arreglos son contenedores N-dimensionales divididos en filas y columnas. Las arrays son tipos de datos mutables, lo que significa que su contenido se puede modificar, eliminar, sobrescribir, etc.
Las arrays son el tipo heterogéneo de contenedores y, por lo tanto, pueden contener elementos de cualquier tipo de datos. No es obligatorio definir el tipo de datos de una array antes de asignar los elementos a la array. Julia decide automáticamente el tipo de datos de la array analizando los valores que se le asignan. Debido a la naturaleza ordenada de una array, facilita la realización de operaciones en sus valores en función de su índice. 
 

Tipos de arrays

Según sus dimensiones, las arrays pueden ser de tres tipos: 
 

• array 1D
• array 2D
• array 3D

array 1D:

Una array 1D o array unidimensional es una representación lineal de elementos. Una array 1D solo puede tener una fila o una columna. Representa un tipo de lista a la que se puede acceder mediante ubicaciones de memoria posteriores. Una array 1D en Julia se conoce como Vector. A diferencia de otros tipos de arrays, los vectores permiten agregar elementos desde el frente o desde atrás, lo que resulta en el cambio de tamaño de la array. 
Ejemplo: 
 

A = [1, 2, 3, 4]
4-element Array{Int64, 1}:
 1
 2
 3
 4

Array 2D:

Una array 2D o array bidimensional es una representación de elementos en forma de filas y columnas. A diferencia de los vectores, las arrays 2D son una representación tabular de datos. Una array 2D en Julia se conoce como Matrix. Se accede a los elementos en Matrix con el uso de índice de fila y columna. Se puede crear una array 2D eliminando las comas entre los elementos de un vector en el momento de la creación de la array.
 

A = [1 2; 3 4]

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

Array 3D:

Una array 3D o array tridimensional es una array de arrays. Una array 3D también se conoce como array multidimensional. Una array 3D es del tipo NxNxN donde la combinación de arrays puede tener cualquier dimensión. Se puede crear una array 3D con el uso del comando cat o reformar .
Ejemplo: 
 

A = cat([1 2; 3 4], [5 6; 7 8], dims=3)

2×2×2 Array{Int64, 3}:
[:, :, 1] =
 1  2
 3  4

[:, :, 2] =
 5  6
 7  8

Aquí, puede dar cualquier valor para ‘ dims ‘ y se creará una array de esa dimensión. 

Se puede crear una array en Julia con el uso de una palabra clave predefinida Array() o simplemente escribiendo los elementos de la array entre corchetes ([]). Hay diferentes formas de crear diferentes tipos de arreglos. 
 

• Se puede crear una array 1D simplemente escribiendo los elementos de la array entre corchetes separados por comas (,) o punto y coma (;). 
   
• Se puede crear una array 2D escribiendo un conjunto de elementos sin comas y luego separando ese conjunto con otro conjunto de valores por un punto y coma. 
   
• De manera similar, se puede crear una array 3D usando el comando ‘cat’. Este comando toma arrays y el número de dimensiones requeridas como entrada y luego concatena las arrays en dimensiones dadas. 
   

Sintaxis: 
 

Array1 = [Value1, Value2, Value3, ...]
or
Array1 = [Value1 Value2 ; Value3 Value4]
or
Array1 = cat([Value Value; Value Value], [Value Value; Value Value], dims=3)

# Julia program to illustrate
# the use of Arrays
 
# Creating a 1D array
Array1 = [1, 2, 3, 4]
println(Array1)
 
# Creating a 2D array
Array2 = [1 2 3; 4 5 6]
println(Array2)
 
# Creating a 3D array
# using 'cat' command
Array3 = cat([1 2; 3 4], [5 6; 7 8], [2 2; 3 4], dims = 3)
println(Array3)

Producción: 
 

Los elementos de una array se pueden extraer fácilmente con el uso de corchetes ([]). Los bucles también se pueden usar para extraer más de un elemento de una array. Además, también se puede extraer un rango de elementos de una array pasando un rango entre corchetes al igual que las tuplas.
Ejemplo: acceder a elementos en una array 1D 
 

# Julia program to illustrate
# the use of Arrays
 
# Creating a 1D Array
Array1 = [1, 2, 3, 4, "Hello", "Geeks"]
 
# Passing index value
println(Array1[3])
 
# Accessing last value
println(Array1[end])
 
# Passing a bunch of index values
println(Array1[[3, 5, 6]])
 
# Passing a range of indices
println(Array1[3:end])
 
# Using true-false to print values
println(Array1[[true, true, false, false, false, true]])

  
Ejemplo: acceder a elementos en una array 2D 
 

# Julia program to illustrate
# the use of Arrays
 
# Creating a 2D Array
Array1 = [1 2 "Hello"; 3 4 "Geeks"]
 
# Passing index value
# row-column wise
println(Array1[1, 3])
 
# Accessing last value
println(Array1[2, end])
 
# Using getindex() function
println(getindex(Array1, 2, 3))
 
# Using colon to indicate every row
println(Array1[:, 3])
 
# Using colon to indicate every column
println(Array1[1, :])

  
Ejemplo: acceder a elementos en una array 3D 
 

# Julia program to illustrate
# the use of Arrays
  
# Creating a 3D array
# using 'cat' command
Array3 = cat([1 2; 3 4],
              ["hello" "Geeks"; "Welcome" "GFG"],
              [5 6; 7 8], dims = 3)
  
# Accessing element using index value
println(Array3[1, 2, 2])
  
# Accessing Range of elements
println(Array3[1:2, 1:2, 2])
  
# Using colon to access every row or column
println(Array3[:, :, 3])
  
# Using getindex function
println(getindex(Array3, 1, 2, 2))
  
# Using getindex with colon operator
println(getindex(Array3, 1, :, 2))

Las arrays son colecciones de tipos mutables en Julia, por lo tanto, sus valores se pueden modificar con el uso de ciertas palabras clave predefinidas. ¡ Julia permite agregar nuevos elementos en una array con el uso de push! dominio. ¡ Los elementos en una array también se pueden agregar en un índice específico pasando el rango de valores de índice en el empalme! función.
Ejemplo: Agregar elemento en array 1D 
 

# Julia program to illustrate
# the use of Arrays
 
# Creating a 1D Array
Array1 = [1, 2, 3, 4, "Hello", "Geeks"]
 
# Adding element at the end
push !(Array1, "Welcome")
println(Array1)
 
# Adding element at the beginning
pushfirst !(Array1, 0)
println(Array1)
 
# Adding element at specific position
splice !(Array1, 3:4, "GFG")
println(Array1)
 
# Adding a range of elements
splice !(Array1, 6:7, [1, 2, 3])
println(Array1)

  
Ejemplo: agregar elementos en una array 2D 
 

# Julia program to illustrate
# the use of Arrays
 
# Creating a 2D Array
Array1 = [1 2 "Hello"; 3 4 "Geeks"]
 
# Array of elements which are to be added
Array2 = [5 6 7; 8 9 10]
 
# Appending arrays
Array3 = [Array1; Array2]
println(Array3)

  
Ejemplo: agregar elementos en una array 3D 
 

# Julia program to illustrate
# the use of Arrays
  
# Creating a 2D Array
Array1 = cat([1 2; 3 4],
             ["hello" "Geeks"; "Welcome" "GFG"],
             dims = 3)
  
# Array of elements which is to be added
Array2 = cat([0 2; 1 4],
             ["GFG" "Geeks"; "abc" "def" ],
             dims = 3)
  
# Appending arrays
Array3 = [Array1; Array2]
println(Array3)

Las arrays en Julia son mutables y, por lo tanto, permiten la modificación de su contenido. Los elementos de las arrays se pueden eliminar o actualizar según los requisitos. Para actualizar un elemento existente de una array, pase el valor de índice de ese elemento entre corchetes. 
Ejemplo: 
 

# Julia program to illustrate
# the use of Arrays
  
# Creating a 1D array
Array1 = [1, 2, 3, 4, 5, 6, "a", "b"]
println("Existing 1D Array:\n", Array1)
  
# Updating value at specific index
Array1[4] = "Hello"
println("\nUpdated 1D Array:\n", Array1)
  
# Creating a 2D array
Array2 = [1 2 3; 4 5 6]
println("\nExisting 2D Array:\n", Array2)
  
# Updating value at specific index
Array2[2, 2] = 10
println("\nUpdated 2D Array:\n", Array2)
  
# Creating a 3D array
Array3 = cat([1 2; 3 4],
             ["hello" "Geeks"; "Welcome" "GFG"],
             dims = 3)
println("\nExisting 3D Array:\n", Array3)
  
# Updating value at specific index
Array3[2, 2, 2] = "World"
println("\nUpdated 3D Array:\n", Array3)

¡ Julia permite eliminar un elemento de una array 1D utilizando la función pop predefinida! . Esta función simplemente eliminará el último elemento de la array y reducirá el tamaño de la array en 1. Para eliminar el primer elemento de la array, ¡se puede usar popfirst! función. Si es necesario eliminar un elemento de un índice específico en la array, ¡empalme! y borrar! Se pueden utilizar funciones. 
Estos métodos funcionan solo en arrays 1D porque las arrays 2D u otras multidimensionales no permiten eliminar un elemento específico de la array para mantener su orden (fila, columna). Sin embargo, se puede asignar cero o undef en el lugar del elemento a eliminar. Esto no afectará el orden de la array. Otra forma de hacer lo mismo es eliminando una fila o columna completa.
Ejemplo: Eliminación de elementos de una array 1D 
 

# Julia program to illustrate
# the use of Arrays
 
# Creating a 1D array
Array1 = [1, 2, 3, 4, 5, 6, "Hello", "Geeks"]
println("Initial Array:\n", Array1)
 
# Delete last element
# using pop !()
pop !(Array1)
 
# Printing the array
println("\nArray after deleting last element:\n", Array1)
 
# Delete first element
# using popfirst !()
popfirst !(Array1)
println("\nArray after deleting first element:\n", Array1)
 
# Deleting a specific element
# using splice !()
splice !(Array1, 4)
 
println("\nArray after deleting a specific(e.g. 4th) element:\n", Array1)
 
# Deleting a range of elements
# using deleteat !()
deleteat !(Array1, 2:4)
 
println("\nArray after deleting a range(e.g. 2:4) of elements:\n", Array1)
 
# Deleting all the elements
# using empty !()
empty !(Array1)
 
println("\nArray after deleting all the elements:\n", Array1)

  
Ejemplo: Eliminación de elementos de 2D Array 
 

# Julia program to illustrate
# the use of arrays
 
Array2 = [1 2 3; 4 5 6; "Hello" "Geeks" "World"]
println("Initial Array:\n", Array2)
 
# Assigning zero in place of
# element to be deleted(e.g. element at 1, 3)
Array2[1, 3] = 0
 
println("\nZero in place of element to be deleted:\n", Array2)
 
# Assigning undefined value in place of
# element to be deleted(e.g. element at 2, 3)
Array2[2, 3] = undef
 
println("\nundef in place of element to be deleted:\n", Array2)
 
# Deleting entire row of elements(e.g. 2nd row)
Array2 = Array2[1:size(Array2, 1) .!= 2, :]
 
println("\nArray after deleting 2nd row:\n", Array2)
 
# Deleting entire column of elements(e.g. 2nd column)
Array2 = Array2[:, 1:size(Array2, 2) .!= 2]
 
println("\nArray after deleting 2nd column:\n", Array2)

En el código anterior, al eliminar una fila o columna completa, creamos otra array del mismo tamaño y asignamos los elementos a la nueva array, excluyendo la fila o columna que se eliminará. Esto se hace porque la eliminación de una fila o columna de una array no está permitida en Julia. 
  
Ejemplo: Eliminación de elementos de 3D Array 
 

# Julia program to illustrate
# the use of arrays
  
# Creating a 3D array
Array3 = cat([1 2 3; 3 4 5; 5 6 7],
             ["a" "b" "c"; "c" "d" "e"; "e" "f" "g"],
             dims = 3)
println("Initial 3D Array:\n", Array3)
  
# Assigning zero in place of
# element to be deleted(e.g. element at 1, 3, 1)
Array3[1, 3, 1] = 0
  
println("\nZero in place of element to be deleted:\n", Array3)
  
# Assigning undefined value in place of
# element to be deleted(e.g. element at 1, 3, 2)
Array3[1, 3, 2] = undef
  
println("\nundef in place of element to be deleted:\n", Array3)
  
# Deleting entire row of elements(e.g. 2nd row)
Array3 = Array3[1:size(Array3, 2) .!= 2, :, :]
  
println("\nArray after deleting 2nd row:\n", Array2)
  
# Deleting entire column of elements(e.g. 2nd column)
Array3 = Array3[:, 1:size(Array3, 2) .!= 2, :]
  
println("\nArray after deleting 2nd column:\n", Array2)

Métodos de array

.array-table {
familia de fuentes: arial, sans-serif;
borde-colapso: colapso;
borde: 1px sólido #5fb962;
ancho: 100%;

}

.array-table td, th {
color de fondo: #c6ebd9;
borde: 1px sólido #5fb962;
alineación de texto: izquierda;
relleno: 8px;

}
.array-table td:nth-child(odd) {
background-color: #c6ebd9;
}
.array-table th {
borde: 1px sólido #5fb962;

alineación de texto: izquierda;

}
.array-table td
{
borde: 1px sólido #5fb962;
de color negro;
alineación de texto: izquierda! importante;
}