Lenguaje de Programacion Julia (Sesion 3: Tipos de datos compuestos)

Transcript

1. Sesión 3: Tipos de datos compuestos CONTENIDOS Arrays Tuplas Diccionarios Conjuntos Abraham Zamudio Chauca 2026 Aprendemos Juntos Aprendemos Juntos Lenguaje de Programación Julia
2. Objetivos de la Sesión Meta Principal Comprender la arquitectura, sintaxis y operaciones de las cuatro estructuras de datos compuestas fundamentales en Julia, desde una perspectiva matemática y computacional. Operaciones Conceptos Tipado paramétrico Memoria contigua Tablas hash Inmutabilidad JULIA Indexación Broadcasting Teorı́a de conjuntos Estabilidad de tipos Abraham Zamudio Chauca 2 / 55
3. Agenda 1. Arrays (Vectores y Matrices) 2. Tuplas y NamedTuples 3. Diccionarios (Dict) 4. Conjuntos (Set) JULIA Abraham Zamudio Chauca 3 / 55
4. ¿Qué son los Tipos Compuestos? Definición Formal Un tipo compuesto es una estructura de datos que agrupa múltiples valores bajo un único identificador, permitiendo organizar, almacenar y manipular colecciones de información de manera eficiente. Caracterı́stica Clave en Julia En Julia, todos los tipos compuestos son paramétricos: su comportamiento y rendimiento dependen del tipo especı́fico de sus elementos. Array{T , N }, JULIA Dict{K , V }, Set{T } Abraham Zamudio Chauca 4 / 55
5. Jerarquı́a Conceptual AbstractArray Array Tuple Dict Set Observación Todas las estructuras comparten una interfaz común derivada de AbstractArray, lo que permite un diseño de algoritmos genéricos. JULIA Abraham Zamudio Chauca 5 / 55
6. 1. Arrays: Definición Definición Un Array en Julia es una colección mutable, de longitud variable, que almacena elementos del mismo tipo en un bloque de memoria contigua. Propiedades Tipo Paramétrico Mutable: sı́ Homogéneo: sı́ Memoria: contigua Orden: column-major Indexación: base 1 JULIA Array{T, N} T : tipo de elementos N: dimensionalidad Abraham Zamudio Chauca 6 / 55
7. Arrays: Memoria Contigua Modelo de Memoria Los elementos de un Array se almacenan en posiciones consecutivas de memoria RAM, lo que permite: • Acceso O(1) por ı́ndice • Aprovechamiento de la caché del procesador • Operaciones vectorizadas eficientes 1 2 3 4 5 addr addr+8 addr+16 addr+24 addr+32 Consecuencia Esta disposición es la base del alto rendimiento de Julia en cálculo numérico. JULIA Abraham Zamudio Chauca 7 / 55
8. Arrays: Constructores Básicos Sintaxis Literal # Vector (Array 1D) v = [1, 2, 3, 4] # Matriz (Array 2D) M = [1.0 2.0 3.0; 4.0 5.0 6.0] # Array 3D T = cat([1 2; 3 4], [5 6; 7 8], dims=3) Inferencia de Tipos Julia infiere automáticamente el tipo más especı́fico: typeof([1, 2, 3]) = Vector{Int64} JULIA Abraham Zamudio Chauca 8 / 55
9. Arrays: Constructores Paramétricos Funciones Constructoras # Vectores de ceros y unos z = zeros(Float32, 3, 3) u = ones(Int64, 2, 4) # Matriz identidad I_mat = Matrix{Float64}(I, 3, 3) # Valores aleatorios r = rand(2, 4) rn = randn(100) # Rango lineal x = range(0, 1, length=50) # Array con valores especı́ficos c = fill(3.14, 2, 3) JULIA Abraham Zamudio Chauca 9 / 55
10. Arrays: Tipado Explı́cito Declaración de Tipo Estable Es buena práctica especificar el tipo para garantizar type stability: Sintaxis # Vector de enteros de 64 bits v = Int64[1, 2, 3, 4] # Matriz de flotantes de 32 bits M = Float32[1.0 2.0; 3.0 4.0] # Array vacı́o con tipo definido empty_arr = Vector{String}() Precaución Evitar Array{Any, 1}: obliga al compilador a realizar boxing y degrada el rendimiento. JULIA Abraham Zamudio Chauca 10 / 55
11. Arrays: Indexación Regla Fundamental Julia utiliza indexación base 1, coherente con la notación matemática estándar. Acceso a Elementos v = [10, 20, 30, 40, 50] v[1] v[end] v[end-1] # Primer elemento: 10 # Último elemento: 50 # Penúltimo: 40 M = [1 2 3; 4 5 6; 7 8 9] M[2, 3] # Fila 2, columna 3: 6 Palabras Clave begin ≡ primer ı́ndice, JULIA end ≡ último ı́ndice Abraham Zamudio Chauca 11 / 55
12. Arrays: Slicing (Rebanado) Rangos y Subarreglos v = [10, 20, 30, 40, 50, 60] v[2:4] # [20, 30, 40] v[begin:end-2] # [10, 20, 30, 40] v[1:2:end] # [10, 30, 50] (paso 2) M = [1 2 3; 4 5 6; 7 8 9] M[1, :] # Primera fila completa M[:, 2] # Segunda columna completa M[1:2, 2:3] # Submatriz 2x2 Notación El sı́mbolo : representa “todos los elementos” en esa dimensión. JULIA Abraham Zamudio Chauca 12 / 55
13. Arrays: Máscaras Booleanas Filtrado por Condición Permite seleccionar elementos mediante un arreglo de valores booleanos. Ejemplo v = [1, 5, 8, 12, 3, 7] # Máscara booleana mask = v .> 5 # [false, false, true, true, false, true] # Aplicar la máscara v[mask] # [8, 12, 7] # Forma compacta v[v .> 5] # [8, 12, 7] Búsqueda de Índices findall(>(5), v) # [3, 4, 6] findfirst(>(5), v) # 3 JULIA Abraham Zamudio Chauca 13 / 55
14. Arrays: Mutación Convención de Nombres En Julia, las funciones que modifican objetos in-place llevan el sufijo !. Añadir Elementos v = [1, 2, 3] push!(v, 4) # v = [1, 2, 3, 4] push!(v, 5, 6) # v = [1, 2, 3, 4, 5, 6] append!(v, [7, 8]) # v = [1, 2, 3, 4, 5, 6, 7, 8] pushfirst!(v, 0) # Inserta al inicio Costo Computacional push! al final es O(1) amortizado. pushfirst! es O(n). JULIA Abraham Zamudio Chauca 14 / 55
15. Arrays: Eliminación de Elementos Operaciones de Eliminación v = [10, 20, 30, 40, 50] deleteat!(v, 2) # Elimina ı́ndice 2: [10, 30, 40, 50] pop!(v) # Extrae y retorna el último: 50 # v queda: [10, 30, 40] popfirst!(v) # Extrae el primero: 10 # v queda: [30, 40] # Eliminación por máscara v = [1, 2, 3, 4, 5] deleteat!(v, v .> 3) # v = [1, 2, 3] Precaución Todas estas operaciones son O(n) porque requieren reacomodar la memoria. JULIA Abraham Zamudio Chauca 15 / 55
16. Arrays: Broadcasting Definición El broadcasting aplica una operación elemento a elemento entre arreglos, o entre un arreglo y un escalar, sin necesidad de bucles explı́citos. Sintaxis con Punto v = [1, 2, 3, 4] w = [10, 20, 30, 40] v .+ 10 v .* 2 v .ˆ 2 # [11, 12, 13, 14] # [2, 4, 6, 8] # [1, 4, 9, 16] v .+ w v .* w # [11, 22, 33, 44] # [10, 40, 90, 160] Regla El punto (.) antes del operador indica broadcasting. JULIA Abraham Zamudio Chauca 16 / 55
17. Broadcasting con Funciones Aplicación de Funciones v = [0, π/6, π/4, π/3, π/2] sin.(v) exp.(v) log.(v) # Aplica seno a cada elemento # Aplica exponencial # Aplica logaritmo # Funciones personalizadas f(x) = xˆ2 + 1 f.(v) # Broadcasting con función propia # Composición de operaciones 2 .* sin.(v) .+ 1 # Expresión vectorizada completa Ventaja Computacional El broadcasting genera código vectorizado equivalente a bucles optimizados, manteniendo legibilidad matemática. JULIA Abraham Zamudio Chauca 17 / 55
18. Broadcasting: Fusión de Operaciones Fusion Julia fusiona automáticamente múltiples operaciones de broadcasting en un único bucle, evitando la creación de arreglos temporales. Equivalencia # Expresión fusionada (un solo bucle) y = 2 .* x.ˆ2 .+ 3 .* x .+ 1 # Equivalente manual (más verboso) @. y = 2 * xˆ2 + 3 * x + 1 Rendimiento Esta fusión reduce el uso de memoria y mejora el rendimiento, haciendo que el código legible sea también eficiente. JULIA Abraham Zamudio Chauca 18 / 55
19. Arrays: Álgebra Lineal Operaciones Matriciales A = [1 2; 3 4] B = [5 6; 7 8] A * B A’ A * A’ # Producto matricial # Transpuesta (Adjoint) # A por su transpuesta tr(A) det(A) inv(A) eigvals(A) # Traza # Determinante # Matriz inversa # Valores propios # Resolución de sistemas Ax = b b = [1, 2] x = A \ b # Operador backslash JULIA Abraham Zamudio Chauca 19 / 55
20. Arrays: Orden Column-Major Orden de Almacenamiento Julia almacena matrices en orden por columnas (column-major), igual que Fortran, MATLAB y R. Matriz A Memoria 1 4 7 3 6 9 5 8 11 1 4 7 2 5 8 3 6 9 Implicación Iterar por columnas es más eficiente que por filas. JULIA Abraham Zamudio Chauca 20 / 55
21. Arrays: Concatenación Funciones de Unión a = [1, 2, 3] b = [4, 5, 6] vcat(a, b) hcat(a, b) # Concatenación vertical: [1,2,3,4,5,6] # Concatenación horizontal (matriz 3x2) # Sintaxis literal [a; b] # Equivale a vcat [a b] # Equivale a hcat # Matrices A = [1 2; 3 4] B = [5 6; 7 8] [A; B] # Apilamiento vertical (4x2) [A B] # Apilamiento horizontal (2x4) JULIA Abraham Zamudio Chauca 21 / 55
22. Arrays: Reshape y Vistas Redimensionamiento v = [1, 2, 3, 4, 5, 6] # Reshape (no copia datos) M = reshape(v, 2, 3) # Matriz 2x3 T = reshape(v, 3, 2, 1) # Tensor 3D # Vistas (views) - sin copia de memoria v_view = @view v[2:5] # Vista a los elementos 2 a 5 Eficiencia Tanto reshape como @view crean vistas que comparten la memoria con el arreglo original. Modificar la vista modifica el original. Precaución Usar @view en lugar de slicing normal evita copias innecesarias de datos. JULIA Abraham Zamudio Chauca 22 / 55
23. Transición: De Arrays a Tuplas Arrays Tuplas Inmutables Heterogéneos Tamaño fijo Stack Mutables Homogéneos Memoria dinámica Heap Cambio de Paradigma Las tuplas sacrifican mutabilidad a cambio de velocidad y seguridad de tipos. JULIA Abraham Zamudio Chauca 23 / 55
24. 2. Tuplas: Definición Definición Una tupla es una colección fija, ordenada e inmutable de elementos que pueden ser de tipos diferentes. Propiedades Tipo Paramétrico Mutable: no Homogéneo: no Longitud: fija Memoria: stack JULIA Tuple{T1, T2, ...} Cada posición tiene su propio tipo Abraham Zamudio Chauca 24 / 55
25. Tuplas: Sintaxis Básica Construcción # Tupla heterogénea t = (1, 3.1415, "texto", [1, 2]) # Tupla de un solo elemento (¡requiere coma!) t1 = (42,) # Tupla vacı́a empty_t = () # Tupla anidada nested = ((1, 2), (3, 4), (5, 6)) Coma Obligatoria La coma en (42,) es esencial para distinguirlo de una expresión entre paréntesis. JULIA Abraham Zamudio Chauca 25 / 55
26. Tuplas: Inmutabilidad Propiedad Fundamental Una vez creada, una tupla no puede modificarse. Sus elementos no pueden ser reasignados, añadidos o eliminados. Comportamiento t = (1, 2, 3) t[1] # Lectura permitida: 1 t[1] = 10 # ERROR: MethodError # Para "modificar", crear una nueva t_new = (10, t[2], t[3]) # (10, 2, 3) Excepción Si un elemento es mutable (ej. un Array), su contenido interno sı́ puede cambiar. JULIA Abraham Zamudio Chauca 26 / 55
27. Tuplas: Acceso a Elementos Indexación t = (10, 20.5, "hola", ’x’) t[1] t[2] t[3] t[end] t[begin] # 10 (Int64) # 20.5 (Float64) # "hola" (String) # ’x’ (Char) # 10 # Rango (retorna otra tupla) t[2:3] # (20.5, "hola") Introspección typeof(t) # Tuple{Int64, Float64, String, Char} length(t) # 4 eltype(t) # Any JULIA Abraham Zamudio Chauca 27 / 55
28. Tuplas: Desestructuración Asignación Múltiple Las tuplas permiten desempaquetar sus elementos en variables individuales de forma simultánea. Sintaxis t = (1, 2.5, "texto") a, b, c = t # a=1, b=2.5, c="texto" # Ignorar elementos con _ x, _, z = t # x=1, z="texto" # Intercambio de variables (sin temporal) a, b = 10, 20 a, b = b, a # Ahora a=20, b=10 Requisito El número de variables debe coincidir con el de elementos (o usar ). JULIA Abraham Zamudio Chauca 28 / 55
29. Tuplas: Broadcasting Operaciones Elemento a Elemento Al ser inmutables, el broadcasting retorna una nueva tupla. Ejemplos (1, 2, 3) .+ (10, 20, 30) # (11, 22, 33) (1, 2, 3) .* 2 # (2, 4, 6) (1.0, 2.0, 3.0) .ˆ 2 # (1.0, 4.0, 9.0) sin.((0.0, π/2, π)) # (0.0, 1.0, ˜0.0) # Combinación con Arrays (1, 2, 3) .+ [10, 20, 30] # Array [11, 22, 33] Nota Las tuplas deben tener la misma longitud para broadcasting directo. JULIA Abraham Zamudio Chauca 29 / 55
30. NamedTuples: Tuplas con Nombre Definición Una NamedTuple es una tupla donde cada elemento tiene una etiqueta (clave) asociada, combinando la eficiencia de las tuplas con la legibilidad de los diccionarios. Sintaxis # NamedTuple con etiquetas nt = (x = 1.0, y = 2.5, z = -1.0) # NamedTuple vacı́o empty_nt = NamedTuple() # NamedTuple anidado persona = (nombre = "Ana", edad = 30, ciudad = "Lima") Tipo Paramétrico NamedTuple{(:x, :y, :z), Tuple{Float64, Float64, Float64}} JULIA Abraham Zamudio Chauca 30 / 55
31. NamedTuples: Acceso a Campos Múltiples Formas de Acceso nt = (x = 1.0, y = 2.5, z = -1.0) # Acceso por punto (más común) nt.x # 1.0 nt.y # 2.5 # Acceso por sı́mbolo nt[:x] # 1.0 # Acceso por posición (como tupla normal) nt[1] # 1.0 nt[2] # 2.5 # Desestructuración con nombres (; x, y, z) = nt # x=1.0, y=2.5, z=-1.0 JULIA Abraham Zamudio Chauca 31 / 55
32. NamedTuples: Operaciones Manipulación nt = (x = 1.0, y = 2.5, z = -1.0) # Obtener claves y valores keys(nt) # (:x, :y, :z) values(nt) # (1.0, 2.5, -1.0) # Verificar existencia haskey(nt, :x) # true # Merge (fusión) nt1 = (a = 1, b = 2) nt2 = (b = 20, c = 30) merge(nt1, nt2) # (a = 1, b = 20, c = 30) # Broadcasting nt .+ (x = 10, y = 10, z = 10) JULIA Abraham Zamudio Chauca 32 / 55
33. Tuplas: Retorno Múltiple Patrón Idiomático Las funciones en Julia retornan una sola tupla. El retorno múltiple es una ilusión sintáctica basada en desestructuración. Ejemplo function estadisticas(v) return minimum(v), maximum(v), mean(v) end # El retorno es una tupla resultado = estadisticas([1, 2, 3, 4, 5]) # resultado = (1, 5, 3.0) # Desestructuración inmediata min_val, max_val, promedio = estadisticas([1, 2, 3, 4, 5]) Eficiencia Las tuplas retornadas se asignan en el stack, sin overhead de memoria. JULIA Abraham Zamudio Chauca 33 / 55
34. Tuplas: Cuándo Usarlas Usar Tuplas Usar Arrays Retorno múltiple Coordenadas fijas (x,y,z) Argumentos de funciones Datos heterogéneos pequeños Claves de diccionario Colecciones grandes Datos homogéneos Necesidad de mutación Cálculo matricial Datos de tamaño variable Regla Práctica Si los datos no cambian y son pequeños ⇒ tupla. Si los datos crecen o son numéricos ⇒ array. JULIA Abraham Zamudio Chauca 34 / 55
35. 3. Diccionarios: Definición Definición Un diccionario es una colección mutable de pares clave ⇒ valor, implementada mediante tablas hash. Propiedades Tipo Paramétrico Mutable: sı́ Claves únicas: sı́ Orden: no garantizado Acceso: O(1) promedio JULIA Dict{K, V} K : tipo de las claves V : tipo de los valores Abraham Zamudio Chauca 35 / 55
36. Diccionarios: Tablas Hash Mecanismo Interno Las tablas hash aplican una función hash h : K → {0, 1, . . . , m − 1} a cada clave para determinar su posición en memoria. Clave h(k ) Valor ”alpha” 3 1 ”beta” 7 2.0 Complejidad Inserción, consulta y eliminación: O(1) promedio, O(n) peor caso. JULIA Abraham Zamudio Chauca 36 / 55
37. Diccionarios: Construcción Sintaxis # Inferencia de tipos d1 = Dict("alpha" => 1, "beta" => 2.0, "gamma" => 3) # Tipo explı́cito (recomendado) d2 = Dict{String, Int64}("a" => 10, "b" => 20) # Diccionario vacı́o d3 = Dict{Symbol, Float64}() # Desde arreglos claves = ["x", "y", "z"] valores = [1, 2, 3] d4 = Dict(zip(claves, valores)) # Usando sı́mbolos (más eficiente) d5 = Dict(:pi => 3.14159, :e => 2.71828) JULIA Abraham Zamudio Chauca 37 / 55
38. Diccionarios: Inserción y Actualización Operaciones d = Dict{String, Int64}() # Inserción de nuevo par d["alpha"] = 1 d["beta"] = 2 # Actualización de valor existente d["alpha"] = 100 # Sobrescribe # Inserción con verificación d["gamma"] = get!(d, "gamma", 3) # Solo si no existe # Merge de diccionarios d1 = Dict("a" => 1, "b" => 2) d2 = Dict("b" => 20, "c" => 30) merge(d1, d2) # Nuevo Dict (no modifica originales) merge!(d1, d2) # Modifica d1 in-place JULIA Abraham Zamudio Chauca 38 / 55
39. Diccionarios: Consulta Segura Acceso a Valores Existen múltiples formas de consultar valores, con diferentes comportamientos ante claves inexistentes. Métodos de Consulta d = Dict("a" => 1, "b" => 2, "c" => 3) # Acceso directo (lanza error si no existe) d["a"] # 1 d["z"] # ERROR: KeyError # Acceso seguro con valor por defecto get(d, "a", 0) # 1 get(d, "z", 0) # 0 (no error) # Verificar existencia haskey(d, "a") # true "a" in keys(d) # true JULIA Abraham Zamudio Chauca 39 / 55
40. Diccionarios: Vistas e Iteración Iteradores d = Dict("a" => 1, "b" => 2, "c" => 3) # Vistas (no copian datos) keys(d) # Iterador de claves values(d) # Iterador de valores pairs(d) # Iterador de pares # Conversión a arreglos collect(keys(d)) # ["a", "b", "c"] collect(values(d)) # [1, 2, 3] # Tamaño length(d) isempty(d) # 3 # false Orden El orden de iteración no está garantizado y puede variar. JULIA Abraham Zamudio Chauca 40 / 55
41. Diccionarios: Eliminación Operaciones d = Dict("a" => 1, "b" => 2, "c" => 3) # Eliminar par por clave delete!(d, "b") # d = Dict("a" => 1, "c" => 3) # Extraer y eliminar (retorna valor) pop!(d, "a") # Retorna 1, elimina el par pop!(d, "z", 0) # Retorna 0 si no existe # Vaciar diccionario empty!(d) # d = Dict{String, Int64}() # Filtrar pares d = Dict("a" => 1, "b" => 2, "c" => 3) filter(p -> p.second > 1, d) # Dict("b" => 2, "c" => 3) JULIA Abraham Zamudio Chauca 41 / 55
42. Diccionarios: Sı́mbolos como Claves Sı́mbolos en Julia Los Symbol son identificadores internos, inmutables y únicos. Son más eficientes que las cadenas como claves. Comparación # Con Strings (menos eficiente) d1 = Dict("nombre" => "Ana", "edad" => 30) # Con Symbols (más eficiente) d2 = Dict(:nombre => "Ana", :edad => 30) # Acceso d2[:nombre] d2.nombre # "Ana" # También válido (sintaxis de punto) Rendimiento Los sı́mbolos se comparan por identidad (puntero), no por contenido, lo que acelera las operaciones hash. JULIA Abraham Zamudio Chauca 42 / 55
43. 4. Conjuntos: Definición Definición Matemática Un conjunto (Set) es una colección mutable, desordenada de elementos únicos, que implementa la teorı́a de conjuntos matemática. Propiedades Tipo Paramétrico Mutable: sı́ Elementos únicos: sı́ Orden: no Pertenencia: O(1) JULIA Set{T} T : tipo de los elementos Abraham Zamudio Chauca 43 / 55
44. Conjuntos: Construcción Sintaxis # Desde un array (elimina duplicados) S1 = Set([1, 2, 3, 3, 4, 4, 4]) # S1 = Set([1, 2, 3, 4]) # Tipo explı́cito S2 = Set{Float64}([1.1, 2.2, 3.3]) # Conjunto vacı́o S3 = Set{Int64}() # Desde un rango S4 = Set(1:10) # Set([1, 2, ..., 10]) # Conjunto de caracteres S5 = Set("abcabc") # Set([’a’, ’b’, ’c’]) JULIA Abraham Zamudio Chauca 44 / 55
45. Conjuntos: Mutación Operaciones S = Set{Int64}() # Añadir elementos push!(S, 1) # S = Set([1]) push!(S, 2, 3) # S = Set([1, 2, 3]) push!(S, 2) # Ignorado (ya existe) # Eliminar elementos delete!(S, 2) # S = Set([1, 3]) # Extraer elemento arbitrario x = pop!(S) # Extrae y retorna un elemento # Vaciar conjunto empty!(S) # Tamaño length(S) JULIA # Número de elementos Abraham Zamudio Chauca 45 / 55
46. Conjuntos: Pertenencia Notación Matemática Nativa Julia soporta sı́mbolos Unicode para operaciones de teorı́a de conjuntos, haciendo el código más legible y matemático. Operadores S = Set([1, 2, 3, 4, 5]) # Pertenencia (∈ equivale a in) 3 ∈S # true 99 ∈S # false # No pertenencia 99 ∈S / # true # Forma alternativa in(3, S) # true in(99, S) # false Rendimiento La verificación de pertenencia es O(1) promedio gracias a la tabla hash interna. JULIA Abraham Zamudio Chauca 46 / 55
47. Conjuntos: Unión e Intersección Operaciones Binarias A = Set([1, 2, 3, 4]) B = Set([3, 4, 5, 6]) # Unión (A ∪B) union(A, B) A ∪B # Set([1, 2, 3, 4, 5, 6]) # Notación Unicode # Intersección (A ∩B) intersect(A, B) # Set([3, 4]) A ∩B # Notación Unicode # Múltiples conjuntos C = Set([4, 5, 6, 7]) union(A, B, C) # Set([1, 2, 3, 4, 5, 6, 7]) intersect(A, B, C) # Set([4]) JULIA Abraham Zamudio Chauca 47 / 55
48. Conjuntos: Diferencia Operaciones A = Set([1, 2, 3, 4]) B = Set([3, 4, 5, 6]) # Diferencia (A \ B): elementos en A pero no en B setdiff(A, B) # Set([1, 2]) A \ B # Notación Unicode # Diferencia inversa setdiff(B, A) # Set([5, 6]) B \ A # Set([5, 6]) # Diferencia simétrica: en A o B, pero no en ambos symdiff(A, B) # Set([1, 2, 5, 6]) # Versión in-place A_copy = copy(A) setdiff!(A_copy, B) # Modifica A_copy JULIA Abraham Zamudio Chauca 48 / 55
49. Conjuntos: Relaciones de Inclusión Subconjuntos y Superconjuntos A = Set([1, 2, 3, 4, 5]) B = Set([1, 2, 3]) C = Set([1, 2, 6]) # Subconjunto (⊆) B ⊆A # true (B es subconjunto de A) C ⊆A # false # Subconjunto propio (⊊) B ⊊A # true (B ⊆A y B ̸=A) A ⊊A # false # Superconjunto (⊇) A ⊇B # true # Igualdad A == B # false B == Set([1, 2, 3]) # true JULIA Abraham Zamudio Chauca 49 / 55
50. Conjuntos: Operaciones Avanzadas Funciones Útiles S = Set([1, 2, 3, 4, 5]) # Verificar si es subconjunto disjunto A = Set([1, 2]) B = Set([3, 4]) isdisjoint(A, B) # true (no comparten elementos) # Convertir a array collect(S) # [1, 2, 3, 4, 5] (orden arbitrario) # Unión de múltiples conjuntos sets = [Set([1,2]), Set([2,3]), Set([3,4])] reduce(union, sets) # Set([1, 2, 3, 4]) # Cardinalidad length(S) JULIA # 5 Abraham Zamudio Chauca 50 / 55
51. Comparativa de Estructuras Propiedad Array Tupla Dict Set Mutable Sı́ No Sı́ Sı́ Ordenado Sı́ Sı́ No No Homogéneo Sı́ No No Sı́ No Claves Sı́ Elementos únicos No Acceso O(1) O(1) O(1) O(1) Búsqueda O(n) O(n) O(1) O(1) Selección La elección depende de: mutabilidad requerida, homogeneidad de datos, y operaciones frecuentes. JULIA Abraham Zamudio Chauca 51 / 55
52. Estabilidad de Tipos Principio Fundamental En Julia, el rendimiento óptimo requiere que el compilador pueda inferir todos los tipos en tiempo de compilación. Type-Stable Type-Unstable # Tipos concretos v = Int64[1, 2, 3] d = Dict{String, Int64}() # Tipos abstractos v = Any[1, 2.0, "3"] d = Dict{Any, Any}() # El compilador optimiza @code_warntype sum(v) # El compilador no optimiza @code_warntype sum(v) Rendimiento: lento Rendimiento: nivel C Herramienta Usar @code warntype para detectar inestabilidades de tipos. JULIA Abraham Zamudio Chauca 52 / 55
53. Patrones de Diseño Comunes Array de NamedTuples Dict de Arrays # Tabla de datos personas = [ (nombre="Ana", edad=30), (nombre="Luis", edad=25), (nombre="Marı́a", edad=28) ] # Datos agrupados datos = Dict( "edades" => [30, 25, 28], "alturas" => [1.65, 1.80, 1.70] ) # Acceso personas[1].nombre # "Ana" # Acceso datos["edades"][2] # 25 Flexibilidad Las estructuras compuestas pueden anidarse para modelar datos complejos. JULIA Abraham Zamudio Chauca 53 / 55
54. Resumen de la Sesión Arrays Tuplas Inmutables, heterogéneas Stack allocation Retorno múltiple Datos fijos Mutables, homogéneos Memoria contigua Broadcasting Cálculo numérico Diccionarios Conjuntos Pares clave-valor Tablas hash Acceso O(1) Mapeo de datos JULIA Elementos únicos Teorı́a de conjuntos Pertenencia O(1) Operaciones matemáticas Abraham Zamudio Chauca 54 / 55
55. Práctica Recomendada 1. Especificar tipos cuando sea posible para garantizar estabilidad 2. Usar broadcasting en lugar de bucles para operaciones vectorizadas 3. Preferir vistas (@view) para evitar copias innecesarias 4. Usar sı́mbolos como claves en diccionarios para mejor rendimiento 5. Aprovechar NamedTuples para datos estructurados pequeños 6. Usar conjuntos para verificación de pertenencia y operaciones matemáticas 7. Consultar documentación con ?nombre función en el REPL Herramientas de Depuración @code warntype, @time, @btime (BenchmarkTools) JULIA Abraham Zamudio Chauca 55 / 55