Julia Language
Arrays

Sintaxis

• [1,2,3]
• [1 2 3]
• [1 2 3; 4 5 6; 7 8 9]
• Array (tipo, dims ...)
• unos (tipo, dims ...)
• ceros (tipo, dims ...)
• Trues (tipo, dims ...)
• falsas (tipo, dims ...)
• empujar! (A, x)
• pop! (A)
• Unshift! (A, x)
• cambio! (A)

Parámetros

Construcción manual de una matriz simple.

Uno puede inicializar una matriz de Julia a mano, utilizando la sintaxis de los corchetes:

julia> x = [1, 2, 3]
3-element Array{Int64,1}:
 1
 2
 3

La primera línea después del comando muestra el tamaño de la matriz que creó. También muestra el tipo de sus elementos y su dimensionalidad (int en este caso Int64 y 1 , respectivamente). Para una matriz bidimensional, puede usar espacios y punto y coma:

julia> x = [1 2 3; 4 5 6]
2x3 Array{Int64,2}:
 1  2  3
 4  5  6

Para crear una matriz sin inicializar, puede usar el método Array(type, dims...) :

julia> Array(Int64, 3, 3)
3x3 Array{Int64,2}:
 0  0  0
 0  0  0
 0  0  0

Las funciones zeros , ones , trues , falses tienen métodos que se comportan exactamente de la misma manera, pero producen matrices llenas de 0.0 , 1.0 , True o False , respectivamente.

Tipos de matrices

En Julia, los Arrays tienen tipos parametrizados por dos variables: un tipo T y una dimensionalidad D ( Array{T, D} ). Para una matriz unidimensional de enteros, el tipo es:

julia> x = [1, 2, 3];
julia> typeof(x)
Array{Int64, 1}

Si la matriz es una matriz bidimensional, D es igual a 2:

julia> x = [1 2 3; 4 5 6; 7 8 9]
julia> typeof(x)
Array{Int64, 2}

El tipo de elemento también puede ser tipos abstractos:

julia> x = [1 2 3; 4 5 "6"; 7 8 9]
3x3 Array{Any,2}:
 1  2  3   
 4  5 "6"
 7  8  9

Aquí Any (un tipo abstracto) es el tipo de la matriz resultante.

Especificar tipos al crear matrices

Cuando creamos un Array de la manera descrita anteriormente, Julia hará todo lo posible para inferir el tipo adecuado que podamos desear. En los ejemplos iniciales anteriores, Int64 entradas que parecían enteros, por lo que Julia se estableció de manera predeterminada en el tipo Int64 predeterminado. A veces, sin embargo, podríamos ser más específicos. En el siguiente ejemplo, especificamos que queremos que el tipo sea Int8 en su lugar:

x1 = Int8[1 2 3; 4 5 6; 7 8 9]
typeof(x1)  ## Array{Int8,2}

Incluso podríamos especificar el tipo como algo como Float64 , incluso si escribimos las entradas de una manera que podría interpretarse como números enteros de forma predeterminada (por ejemplo, escribir 1 lugar de 1.0 ). p.ej

x2 = Float64[1 2 3; 4 5 6; 7 8 9]

Arreglos de Arrays - Propiedades y Construcción

En Julia, puede tener una matriz que contiene otros objetos de tipo matriz. Considere los siguientes ejemplos de inicialización de varios tipos de Arrays:

A = Array{Float64}(10,10)  # A single Array, dimensions 10 by 10, of Float64 type objects

B = Array{Array}(10,10,10)  # A 10 by 10 by 10 Array.  Each element is an Array of unspecified type and dimension.

C = Array{Array{Float64}}(10)  ## A length 10, one-dimensional Array.  Each element is an Array of Float64 type objects but unspecified dimensions

D = Array{Array{Float64, 2}}(10)  ## A length 10, one-dimensional Array.  Each element of is an 2 dimensional array of Float 64 objects

Considere, por ejemplo, las diferencias entre C y D aquí:

julia> C[1] = rand(3)
3-element Array{Float64,1}:
 0.604771
 0.985604
 0.166444

julia> D[1] = rand(3)
ERROR: MethodError: 

rand(3) produce un objeto de tipo Array{Float64,1} . Dado que la única especificación para los elementos de C es que son matrices con elementos de tipo Float64, esto se ajusta a la definición de C Pero, para D especificamos que los elementos deben ser matrices bidimensionales. Por lo tanto, dado que rand(3) no produce una matriz bidimensional, no podemos usarla para asignar un valor a un elemento específico de D

Especificar dimensiones específicas de matrices dentro de una matriz

Aunque podemos especificar que un Array tendrá elementos que son de tipo Array, y podemos especificar que, por ejemplo, esos elementos deben ser Arrays bidimensionales, no podemos especificar directamente las dimensiones de esos elementos. Por ejemplo, no podemos especificar directamente que queremos una matriz que contenga 10 matrices, cada una de las cuales es 5,5. Podemos ver esto en la sintaxis de la función Array() utilizada para construir un Array:

Array {T} (dims)

construye una matriz densa sin inicializar con el tipo de elemento T. dims puede ser una tupla o una serie de argumentos enteros. La sintaxis Array (T, dims) también está disponible, pero está obsoleta.

El tipo de una matriz en Julia abarca el número de las dimensiones pero no el tamaño de esas dimensiones. Por lo tanto, no hay lugar en esta sintaxis para especificar las dimensiones precisas. Sin embargo, se podría lograr un efecto similar utilizando una comprensión de Array:

E = [Array{Float64}(5,5) for idx in 1:10]

Nota: esta documentación refleja la siguiente respuesta SO

Inicializar una matriz vacía

Podemos usar [] para crear una matriz vacía en Julia. El ejemplo más simple sería:

A = [] # 0-element Array{Any,1}

Las matrices de tipo Any generalmente no funcionarán tan bien como aquellas con un tipo específico. Así, por ejemplo, podemos usar:

B = Float64[]  ## 0-element Array{Float64,1}
C = Array{Float64}[]  ## 0-element Array{Array{Float64,N},1}
D = Tuple{Int, Int}[] ## 0-element Array{Tuple{Int64,Int64},1}

Consulte Inicializar una matriz vacía de tuplas en Julia para ver la fuente del último ejemplo.

Vectores

Los vectores son matrices unidimensionales, y soportan principalmente la misma interfaz que sus homólogos multidimensionales. Sin embargo, los vectores también soportan operaciones adicionales.

Primero, tenga en cuenta que el Vector{T} donde T es algún tipo significa lo mismo que el Array{T,1} .

julia> Vector{Int}
Array{Int64,1}

julia> Vector{Float64}
Array{Float64,1}

Uno lee Array{Int64,1} como "matriz unidimensional de Int64 ".

A diferencia de las matrices multidimensionales, los vectores se pueden redimensionar. Los elementos se pueden agregar o eliminar desde la parte frontal o posterior del vector. Estas operaciones son todas de tiempo amortizado constante .

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

julia> push!(A, 4)
4-element Array{Int64,1}:
 1
 2
 3
 4

julia> A
4-element Array{Int64,1}:
 1
 2
 3
 4

julia> pop!(A)
4

julia> A
3-element Array{Int64,1}:
 1
 2
 3

julia> unshift!(A, 0)
4-element Array{Int64,1}:
 0
 1
 2
 3

julia> A
4-element Array{Int64,1}:
 0
 1
 2
 3

julia> shift!(A)
0

julia> A
3-element Array{Int64,1}:
 1
 2
 3

Como es convención, cada una de estas funciones push! , pop! , sin unshift! , y shift! termina en un signo de exclamación para indicar que están mutando su argumento. Las funciones push! y sin unshift! devuelve la matriz, mientras que pop! y shift! Devuelve el elemento eliminado.

Concatenación

A menudo es útil construir matrices a partir de matrices más pequeñas.

Concatenacion horizontal

Las matrices (y los vectores, que se tratan como vectores de columna) se pueden concatenar horizontalmente mediante la función hcat .

julia> hcat([1 2; 3 4], [5 6 7; 8 9 10], [11, 12])
2×6 Array{Int64,2}:
 1  2  5  6   7  11
 3  4  8  9  10  12

Existe una sintaxis de conveniencia disponible, utilizando la notación entre corchetes y los espacios:

julia> [[1 2; 3 4] [5 6 7; 8 9 10] [11, 12]]
2×6 Array{Int64,2}:
 1  2  5  6   7  11
 3  4  8  9  10  12

Esta notación puede coincidir estrechamente con la notación para matrices de bloques utilizadas en álgebra lineal:

julia> A = [1 2; 3 4]
2×2 Array{Int64,2}:
 1  2
 3  4

julia> B = [5 6; 7 8]
2×2 Array{Int64,2}:
 5  6
 7  8

julia> [A B]
2×4 Array{Int64,2}:
 1  2  5  6
 3  4  7  8

Tenga en cuenta que no puede concatenar horizontalmente una sola matriz utilizando la sintaxis [] , ya que en su lugar crearía un vector de un elemento de matrices:

julia> [A]
1-element Array{Array{Int64,2},1}:
 [1 2; 3 4]

Concatenacion vertical

La concatenación vertical es como la concatenación horizontal, pero en la dirección vertical. La función para la concatenación vertical es vcat .

julia> vcat([1 2; 3 4], [5 6; 7 8; 9 10], [11 12])
6×2 Array{Int64,2}:
  1   2
  3   4
  5   6
  7   8
  9  10
 11  12

Alternativamente, la notación de corchete se puede utilizar con punto ; coma ; como el delimitador

julia> [[1 2; 3 4]; [5 6; 7 8; 9 10]; [11 12]]
6×2 Array{Int64,2}:
  1   2
  3   4
  5   6
  7   8
  9  10
 11  12

Los vectores también se pueden concatenar verticalmente; el resultado es un vector:

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

julia> B = [4, 5]
2-element Array{Int64,1}:
 4
 5

julia> [A; B]
5-element Array{Int64,1}:
 1
 2
 3
 4
 5

La concatenación horizontal y vertical se puede combinar:

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

julia> B = [5 6 7]
1×3 Array{Int64,2}:
 5  6  7

julia> C = [8, 9]
2-element Array{Int64,1}:
 8
 9

julia> [A C; B]
3×3 Array{Int64,2}:
 1  2  8
 3  4  9
 5  6  7