Estructuras en Julia (7ª parte – ¡Hola Julia!)

Hasta este momento en todas las entradas solamente se han utilizado los tipos de datos disponibles de forma nativa en Julia. A pesar de existir una gran calidad de tipos, no son suficientes para subir cualquier situación. Por lo que puede ser necesario crear tipos de datos personalizados. Algo que se puede conseguir mediante el uso de las estructuras en Julia.

Creación de una estructura en Julia

Cuando necesitamos un tipo de dato personalizado podemos recurrir a las estructuras. Estas se crean con la palabra reservada struct seguida del nombre que se le queremos asignar. En las siguientes líneas, hasta que se encuentra la palabra end, enumeramos todos las propiedades que deseamos incluir en la estructura. Por ejemplo, si queremos crear un tipo Punto en un espacio bidimensional solamente hay que escribir.

struct Punto
    x
    y
end

En donde la estructura contiene dos propiedades x e y. Para crear un objeto de este tipo solamente hay que llamar a la estructura seguida de las propiedades entre paréntesis. Usando la notación punto para acceder a cada uno de los elementos.

p = Punto(3, 4)

p.x # 3
p.y # 4

Estructuras mutables

Por defecto las estructuras son inmutables, por lo que sí intentamos cambiar el valor de una propiedad de una estructura tendremos un error. Esto es, al escribir p.x = 2 en el caso anterior Julia nos dará un error del tipo setfield! immutable struct of type Punto cannot be changed.

La solución es usar el modificador mutable antes de definir la estructura, con lo que se podrán cambiar los valores de las propiedades.

mutable struct PuntoMutable
    x
    y
end

p = PuntoMutable(3, 4)

p.y = 3

En este ejemplo vemos que el punto creado inicialmente como (3, 4) se puede convertir sin problemas en (3, 3). Ya que ahora la estructura es mutable.

Estructura dentro de estructuras

Las estructuras también se pueden usar dentro de otras estructuras, lo que facilita la creación de tipos más complejos. Por ejemplo, podemos crear un objeto rectángulo donde tenemos el ancho, alto y objeto punto que defina la posición inicial.

struct Rectángulo
    ancho
    alto
    posición
end

r = Rectángulo(10, 20, Punto(2,3))

Tipos de datos dentro de las estructuras

En el ejemplo anterior posición es un punto porque lo hemos usado así, pero no se ha indicado de forma explícita. Por lo que también se podría crear el rectángulo de la siguiente forma r = Rectángulo(10, 20, 2) aunque sea el uso que deseamos para el tipo. Por fortuna es posible seleccionar los tipos de datos que queremos para cada propiedad. En este caso, tanto ancho como alto son números y posición es un Punto. Así se puede crear un nuevo tipo con estas definiciones.

struct RectánguloTipos
    ancho::Number
    alto::Number
    posición::Punto
end

r = RectánguloTipos(10, 20, Punto(2,3))

Ahora, si se intenta crear un RectánguloTipos con la expresión r = RectánguloTipos(10, 20, 2) Julia no lo permitirá. Generando el siguiente error MethodError: Cannot `convert` an object of type Int64 to an object of type Punto. Algo que nos puede evitar muchos problemas cuando alguien use nuestra estructura y espere que en posición se encuentre un Punto y no una cadena de texto o un valor real.

Sobrecarga de funciones

Es posible definir diferentes implementaciones de una función para operar con diferentes tipos de datos. Lo que nos ofrece una capa de abstracción. Al escribir una función que requiere un tipo de dato y otra que requiera otra Julia se encargará de ejecutar la correcta en cada momento. O de indicarnos que no existe una versión compatible. Por ejemplo, si queremos representar la posición de un punto, sea este de tipo Punto o de tipo Rectángulo se puede usar el siguiente código.

function imprimePunto(p::Punto)
    println("La coordenada es ($(p.x),$(p.y))")
end

function imprimePunto(p::Rectángulo)
    println("La coordenada es ($(p.posición.x),$(p.posición.y))")
end

imprimePunto(Punto(3, 4))
imprimePunto(Rectángulo(4, 5, Punto(1, 1)))

La coordenada es (3,4)
La coordenada es (1,1)

Aunque posiblemente la mejor implementación sea que imprimePunto para el tipo Rectángulo llame a la versión de Punto. Lo que hace el código más fácil de mantener al no duplicar líneas.

function imprimePunto(p::Rectángulo)
    imprimePunto(p.posición)
end

Sobrecarga de operadores

También se puede sobrecargar los operadores como suma, multiplicación, etc. Para ello es enserio importar desde Base el operador u operadores que necesitemos. Luego simplemente la definición del operador para el tipo se hace igual que como una función, usando como nombre el operador. Así para definir el operador multiplicación de un Punto solo hay que hacer lo siguiente.

import Base.*

function *(p::Punto, x::Number)
    Punto(p.x * x, p.y * x)
end

Punto(1,1) * 2 # (2, 2)

Tipos mutables y no mutables en funciones

Al ver por primera vez las funciones ya explicamos la diferencia entre los tipos mutables y no mutables. Si se pasa un tipo mutables esta podrá modificar el valor de la variable y este cambio se verá fuera de la función. Por lo que es necesario tener cuidado a la hora de trabajar con tipos mutables. Por ejemplo, se le puede sumar a un punto una posición con la siguiente función

function sumaPuntos(p::PuntoMutable, δx, δy) p.x += δx p.y += δy end p = PuntoMutable(1,1) sumaPuntos(p, 2, 2) p # (3, 3)

Observando en este caso que el valor de p al salir de sumaPuntos no es (1, 1), sino que (3, 3). Ya que el valor se ha cambiado dentro de la función.

Para evitar este comportamiento se puede usar la función deepcopy(p), lo que creará una copia profunda del dato. Es decir, una nueva instancia de este con los mismos valores.

p1 = PuntoMutable(2,2)
p2 = deepcopy(p1)
p1 ≡ p2 # False (no es el mismo objeto)
p2 == p2 # True (pero tienen los mismos valores)

Retornar tipos

Las funciones de Julia también pueden retornar tipos de datos que son creado por nosotros. Podemos crear una función para crear el punto medio de dos puntos y que esta retorna un nuevo Punto.

function puntoMedio(p1::Punto, p2::Punto)::Punto
    Punto((p1.x + p2.x)/2, (p1.y + p2.y)/2)
end

puntoMedio(Punto(0,0), Punto(2,2)) # (1.0, 1.0)

En este caso no es necesario que indicar que tiene que retornar un tipo Punto, ya que por defecto devuelve un tipo Any. Pero puede simplificar la lectura del código.

Constructores

Las estructuras tienen un constructor por defecto que crea Julia, simplemente los tipos seguidos de comas. Pero puede ser que el comportamiento que deseemos para nuestro tipo. Podemos pensar en valores por defecto o calculados. En estos casos hay que recurrir a los constructores. Los cuales son funciones con el nombre del tipo que se escriben dentro de la estructura.

struct Punto
    x
    y
     
    function Punto(x::Number=0, y::Number=0)
        new(x,y)
    end
end

Punto(1) # (1, 0)

Quizás lo más importante es que para crear el tipo dentro del constructor hay que llamar a new dentro de la función y no al tipo. Además de esto, al definir valores por defecto, evitamos que sea necesario incluir toda la información.

Esto se puede extender al tipo Rectángulo para crear dos constructores, uno que función con Punto y otro que funcione con cuatro números.

struct RectánguloTipos
    ancho::Number
    alto::Number
    posición::Punto
    
    function RectánguloTipos(ancho::Number=5, alto::Number=5, posición::Punto=Punto())
        new(ancho, alto, posición)
    end
    
    function RectánguloTipos(ancho::Number=5, alto::Number=5, x::Number=0, y::Number=0)
        new(ancho, alto, Punto(x, y))
    end
end

RectánguloTipos(10, 2, Punto(1,2))
RectánguloTipos(10, 2, 2, 2)

Muchas posibilidades con las estructuras en Julia

Las estructuras en Julia es un recurso que ofrece muchas posibilidades a los usuarios. Crear nuestros propios tipos de datos nos puede ayudar a crear mejores programas.

Tal vez la única mala noticia es que Julia, hoy en día, no cuenta con clases en el sentido de programación orientada a objetos. El paradigma principal es la sobrecarga de funciones para trabajar de forma coherente con los datos.