?

Log in

No account? Create an account

Publicaciones anteriores | Publicaciones siguientes

Arreglos en Julia

Al igual que los enteros, los números de coma flotante, los números complejos, los tipos de datos de números racionales y los tipos de datos de números irracionales definen valores únicos de tipos diferentes, también existe un host de otros tipos de datos que contienen varios valores al mismo tiempo. Estos tipos de datos incluyen Array, Tuple (tuples), Dict (diccionario) y Set (sets).
Las matrices son particularmente interesantes ya que se utilizan para definir vectores, tablas y matrices para la informática científica:
·       Una matriz 1D (unidimensional) actúa como un vector o una lista.
·       Una matriz 2D se puede utilizar como una tabla o matriz.
·       Las matrices 3D y más D pueden representar matrices multidimensionales.
Una matriz es una colección ordenada de elementos. Una matriz es un objeto que contiene varias entradas de datos identificadas por sus índices. A diferencia de muchos lenguajes de programación, el índice de matriz Julia comienza en 1, no 0. Una matriz es una colección de objetos, donde estos objetos recopilados se almacenan en una cuadrícula multidimensional.
En el caso más general, una matriz puede contener objetos de tipo Any, lo que significa esencialmente que puede almacenar cualquier variedad de tipos de datos numéricos. Sin embargo, mantener una uniformidad de las estructuras de datos ayuda a administrar los recursos computacionales y evitar errores computacionales numéricos. Por lo tanto, para la mayoría de los propósitos computacionales, las matrices deben contener objetos de un tipo más específico, como Float64 o Int32. Por lo tanto, los objetos de tipo de datos Array pueden contener valores de diferentes tipos de datos o restringirse a valores de un tipo de dato específico.
Construcción
Las matrices a menudo se indican con corchetes y elementos separados por comas. El código siguiente muestra la forma más sencilla de crear matrices a mano:
julia> a = [1,2,3,4]
4-element Array{Int64,1}:
1
2
3
4

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

julia> size(a)
(4,)

julia> size(b)
(1, 4)

julia> ndims(a)
1

julia> ndims(b)
2
Usando el comando a = [1,2,3,4] en REPL hace un array de 4 elementos donde cada elemento se almacena como tipo Int64 (porque los valores de entrada de matrices son enteros y el tipo de datos predeterminado de enteros es Int64) y la matriz se define como una colección de cuatro entradas. La referencia a un objeto de matriz se representa mediante el nombre de variable a. Por otro lado, cuando el comando b = [1 2 3 4] (cada elemento está separado por un espacio en blanco), obtenemos una matriz de 1 x 4. La diferencia entre los dos se puede sondear mediante la emisión de los comandos size() y ndims(), que dan el tamaño en términos de números de filas y columnas. Además, cuando se crea la matriz a, se observa la información 4-element Array{Int64,1}: lo que significa que se trata de una matriz unidimensional que almacena cuatro elementos del tipo de datos Int64, donde como b informa de que 1x4 Array{Int64,2}. En otras palabras, es una matriz bidimensional con la forma 1 x 2 (1 fila y 2 columnas) que almacena elementos del tipo de datos Int64.
Alternativamente, también se puede definir una matriz que contenga números aleatorios con la estructura de comandos Array{data_type}(undef, Number) donde el tipo de datos se define entre llaves y el número de elementos se define entre corchetes simples (). Tenga en cuenta que los elementos se asignan aleatoriamente por lo que el resultado será diferente cada vez que se ejecuta el comando.
Undef: El Alias para UndefInitializer(), que construye una instancia del tipo singleton UndefInitializer, se utiliza en la inicialización de la matriz para indicar que el array-constructor-caller de matriz desea una matriz no inicializada.
Por ejemplo, cuando se emite dos veces el comando a = Array{Int64}(undef,3) , se obtiene una matriz con tres elementos de números aleatorios para el tipo Int64:
julia> a - Matriz-Int64-(undef,3)
Matriz de 3 elementos- Int64,1:
4537699648
4608255472
4608273952

julia> a - Matriz-Int64-(undef,3)
Matriz de 3 elementos- Int64,1:
4537754448
4608245744
4608243248
Matrices de múltiples dimensiones
Del mismo lado que definió una matriz 1D, puede definir matrices multidimensionales introduciendo el número de elementos en cada dimensión. Por ejemplo, a = Array{Int64}(undef,2,3,4) creará una matriz del tamaño 2 × 3 × 4.  La primera dimensión tiene dos valores, la segunda dimensión tiene tres valores y la tercera dimensión tiene cuatro valores:
julia> a = Array{Int64}(undef,2,3,4)
2×3×4 Array{Int64,3}:
[:, :, 1] =
31  34  38
33  36  56

[:, :, 2] =
58  60  85
59  84  86

[:, :, 3] =
4620497920  4620498016  4620498160
4620497968  4620498064  4620498208

[:, :, 4] =
4620498256  4620498352  4620498448
4620498304  4620498400  4608242672
La notación [:,:,1] se aclarará en las secciones posteriores.
Arreglos de Flotantes
Si incluso un elemento de un objeto se define como un número de punto flotante, el tipo de datos de todos los elementos numéricos se convierte en Float64:
julia> a = [1,2.0,3,4]
4-element Array{Float64,1}:
1.0
2.0
3.0
4.0
Vale la pena señalar que la matriz a utiliza 32 bytes para su almacenamiento, ya que cada elemento es de tipo Float64, que utiliza 8 bytes de 8 x 4 = 32 bytes. Por lo tanto, es importante estimar el tamaño necesario para almacenar una matriz cuando contiene un gran número de elementos. Esto es particularmente importante para dispositivos y aplicaciones donde la memoria no es un lujo como los ordenadores de una sola placa (Raspberry Pi, por ejemplo).
Una matriz de números aleatorios se puede crear de una manera similar a la de los enteros:
julia> a = Array{Float64}(undef,7)
7-element Array{Float64,1}:
2.297622476e-314
2.2976225077e-314
2.2976225235e-314
2.2976225393e-314
2.2767736963e-314
2.297622555e-314
2.297817114e-314

julia> a = Array{Float64}(undef,2,3,4)
2×3×4 Array{Float64,3}:
[:, :, 1] =
7.65802e-322  2.28283e-314  1.23516e-322
1.23516e-322  7.70742e-322  2.28283e-314

[:, :, 2] =
8.34971e-322  2.28283e-314  1.23516e-322
1.23516e-322  8.34971e-322  2.28283e-314

[:, :, 3] =
1.55631e-321  2.28283e-314  3.16202e-322
3.16202e-322  1.56125e-321  2.28283e-314

[:, :, 4] =
1.62548e-321  2.28283e-314  3.16202e-322
3.16202e-322  1.62548e-321  2.2911e-314
Matriz de funciones
Dado que los elementos de una matriz pueden ser de cualquier tipo de datos, incluso las funciones matemáticas pueden ser un elemento de una matriz. Una matriz de funciones matemáticas se puede definir de la siguiente manera:
julia> a = [sin,cos,tan,log]
4-element Array{Function,1}:
sin
cos
tan
log
Matrices de tipos de datos mixtos
También es posible crear una matriz de tipos de datos mixtos. Por ejemplo, a = [sin,1,1.5,2+5im,2//3] crea una matriz donde los elementos pertenecen a los tipos de datos Function, Int64, Float64, Complex(Int64) y Rational-Int64:
julia> a = [sin,1,1.5,2+5im,2//3]
5-element Array{Any,1}:
   sin
  1   
  1.5 
2 + 5im
2//3 
Creación de matrices
Hasta este punto, acabamos de aprender a hacer matrices más pequeñas donde el número de elementos es pequeño. ¿Qué sucede si necesita crear una matriz de un gran número de enteros o números de punto flotante separados por valores definidos, digamos enteros impares de 1 a 1000? No le gustaría alimentar estos elementos de matrices a mano. El operador : es útil en este caso.
El operador n:m define un rango de n a m y, por lo tanto, se puede utilizar para crear una matriz de una secuencia de números. Usando la función collect(), se puede construir una matriz para un rango predefinido de números. Los números de inicio y parada también pueden ser números de punto flotante:
julia> collect(1:5)
5-element Array{Int64,1}:
1
2
3
4
5
julia> collect(1.1:5.6)
5-element Array{Float64,1}:
1.1
2.1
3.1
4.1
5.1

julia> collect(1:2:1000)
500-element Array{Int64,1}:
   1
  3
  5
  7
  9
11
13
15
17
19
  
983
985
987
989
991
993
995
997
999
Vale la pena señalar que el incremento (diferencia) entre los elementos se establece en 1 de forma predeterminada. Esto se puede cambiar según sea necesario de la siguiente manera:
julia> collect(1:2:9)
5-element Array{Int64,1}:
1
3
5
7
9

julia> collect(1.5:2.2:9.9)
4-element Array{Float64,1}:
1.5
3.7
5.9
8.1
Los argumentos se presentan como start:increment:stop. También stop indica el número más grande que puede contener la matriz. Los elementos de una matriz deben ser, como máximo, el número de detención o menos.
Los incrementos también pueden ser números negativos. Por ejemplo:
julia> collect(10.5:-1.2:3.3)
7-element Array{Float64,1}:
10.5
9.3
8.1
6.9
5.7
4.5
3.3

julia> collect(10:-3.2:1)
3-element Array{Float64,1}:
10.0
6.8
3.6

julia> collect(10:-3:1)
4-element Array{Int64,1}:
10
7
4
1

julia> collect(1:-3:10)
0-element Array{Int64,1}
El comando collect(1:-3:10) produce una matriz nula (una matriz con cero elementos) ya que los incrementos negativos no se pueden implementar a partir de 1 a 10.
Creación de una matriz mediante el operador de puntos suspensivos
El operador de puntos suspensivos ... se puede utilizar para crear una matriz con un rango de objetos sin utilizar la función collect():
julia> a = [1:5...]
5-element Array{Int64,1}:
1
2
3
4
5

julia> a = [1:2:9...]
5-element Array{Int64,1}:
1
3
5
7
9

julia> a = [1.2:2.2:9.9...]
4-element Array{Float64,1}:
1.2
3.4
5.6
7.8
Matrices similares
La función integrada similar() crea una matriz que es similar a una matriz determinada pero que puede ser diferente en el tipo de datos de los elementos. Por ejemplo, supongamos que se ha creado una matriz de 2 x 3 con el tipo de datos Float64 y se guarda en el nombre de variable A. A continuación, se puede crear una nueva matriz guardada en el nombre de variable A1 de la misma forma pero con el tipo de datos Int8:
julia> A = Array{Float64}(undef,2,3)
2×3 Array{Float64,2}:
2.29765e-314  2.29765e-314  2.29765e-314
2.29765e-314  2.29765e-314  2.29782e-314

julia> similar(A,Int8)
2×3 Array{Int8,2}:
64  -28  1
66   18  0
Del mismo modo, se puede crear una matriz de tipo de datos Float64 a partir de una matriz de números booleanos:
julia> A = Array{Bool}(undef,2,3)
2×3 Array{Bool,2}:
false  false   true
true  false  false

julia> similar(A,Float64)
2×3 Array{Float64,2}:
0.0  0.0  0.0
0.0  0.0  0.0
Propiedades de los arrays
Se puede utilizar una variedad de funciones integradas para sondear varias propiedades de objetos de matriz. Aquí dos de ellos, size()y ndims():
eltype: Tipo de elemento
julia> A = [1,2,3,4]
4-element Array{Int64,1}:
1
2
3
4
julia> eltype(A)
Int64

longitud: Número de elementos
julia> A = [1.1,-2.9,3.7,4.9]
4-element Array{Float64,1}:
1.1
-2.9
3.7
4.9

julia> length(A)
4
ndims: Número de dimensiones
julia> A = Array{Int64}(undef,2,3,5)
2×3×5 Array{Int64,3}:
[:, :, 1] =
0  0  0
0  0  0

[:, :, 2] =
0  0  0
0  0  0

[:, :, 3] =
0  0  0
0  0  0

[:, :, 4] =
0  0  0
0  0  0

[:, :, 5] =
0  0  0
0  0  0
julia> ndims(A)
3

julia> A = Array{Float64}(undef,6)
6-element Array{Float64,1}:
2.2134070974e-314
2.2124618905e-314
2.2785901504e-314
2.213408947e-314
2.2125587985e-314
2.278590593e-314

julia> ndims(A)
1
size(): Tamaño de la matriz (cuántos elementos existen en cada una de sus dimensiones)

julia> size(A) # No elementos en cada dimension
(2, 4, 3)

julia> size(A,3) # No elementos en la 3ra dimension
3

julia> size(A,2) # No elementos en la 2ra dimension
4

julia> size(A,1) # No elementos en la 1ra dimension
2

Referencias:
Beginning Julia Programming: For Engineers and Scientists. Sandeep Nagar. Apress

Perfil

deoxyt2
Juan Rodrigo Anabalón R.
Website

Acerca de mi

He estado escribiendo sobre temas de seguridad en Livejournal desde el 2008 y en mi horrible y extinto MSN Spaces desde el 2006. En la actualidad, soy CISO en MonkeysLab y Presidente en ISSA Chile.




MonkeysLab




Copyleft

Copyleft: Atribuir con enlace.







Flickr


ISSA Chile



contador de visitas


contadores gratis

Último mes

September 2019
S M T W T F S
1234567
891011121314
15161718192021
22232425262728
2930     

Tags

Powered by LiveJournal.com
Designed by Lilia Ahner