Tipos de datos en Julia (9ª parte – ¡Hola Julia!)

En esta entrada y la siguiente nos vamos a para un momento en conceptos teóricos sobre los tipos de datos en Julia. Creo que es importante conocer cómo funcionan los tipos de datos para poder sacar un mayor provecho de las posibilidades que nos ofrece el lenguaje.

Comprobar el tipo de una variable

Si tenemos una variable en nuestro espacio de trabajo podemos comprobar el tipo al que pertenece con la función typeof(). Una función que nos devolverá el identificador del tipo de dato, lo que se puede obtener tanto sobre constantes o variables.

typeof(1)   # Int64
typeof(π)   # Irrational{:π}
typeof(1.0) # Float64

Asignación de los tipos de datos en Julia

Como hemos visto en las entradas anteriores el operador para indicar el tipo de dato en Julia es ::. Generalmente indicamos el nombre de una variable seguido del operador y el tipo de dato. Lo que hace realmente el operador es comprobar que el valor a la izquierda es del tipo indicado, por eso la siguiente línea produce un error.

12::Float64
TypeError: in typeassert, expected Float64, got Int64

En este caso lo que hemos intentado comprobar si el número entero 12 es de tipo real de 64 bits, lo que no es cierto ya que es un número entero. Pero, cuando es necesarios, podemos convertir unos tipos en otros.

En Analytics Lane

La caverna del consumo, o cómo Greenspan miraba calzoncillos para hacer política monetaria – El bestiario de los indicadores económicos absurdos (parte 1)

Conversión y promoción de tipos

La función que podemos utilizará para convertir un tipo de dato en otra es convert(). A la que es necesario indicarle dos parámetros, en primer lugar el tipo al que deseamos convertir el dato y en segundo el dato. Aunque hay que tener en cuenta que es una función de conversión, si no es posible transformar un dato en otro obtendremos un error.

convert(Float64, 12) # 12.0
convert(Float64, π)  # 3.141592653589793
convert(Int64, 12.0) # 12
convert(Int64, π)    # MethodError: no method matching Int64(::Irrational{:π})

En la primera línea de este ejemplo se transforman un entero en real, en la segunda un tipo irracional en un real, en la tercera se convierte un real, para el que existe una representación como entero, en entero y en la última tenemos un error porque no se puede convertir un valor irracional ene entero sin pérdida de resolución. En este punto es importante notar que si el dato no se puede transformar tendremos un error y no un dato con pérdida de resolución.

Usar la función convert() puede ser un poco tedioso, por lo que se puede realizar las conversiones utilizando solamente el tipo de dato como función. Obteniendo el mismo efecto que en el ejemplo anterior.

Float64(12)
Float64(π)
Int64(12.0)

Además de las conversiones existen las promociones que es lo que se utiliza cuando se opera con valores de diferente tipo. En este caso se se llevan todos los datos al de mayor precisión. Por ejemplo, al escribir la operación x = 2 * π el resultado en la variable x es de tipo Float64, a pesar de que 2 en un entero y π es irracional. Como hemos visto la operación se realiza de forma automática, aunque la podemos forzar mediante la función promote(), la cual devuelve una tupla con los valores promocionados al tipo de mayor resolución en la que se pueden representar todos los datos. Por ejemplo, x = promote(2, π, im) devuelve una tupla de tipo Complex{Int64} ya que el tercer valor es de tipo complejo.

Afortunadamente no es necesario que nos preocupemos de la promoción de tipos ya que Julia lo hace automáticamente cuando es necesario.

Tipos de datos abstractos

En Julia los tipos de datos son objetos, por eso unos heredan de otros. Por ejemplo, el tipo Int64 hereda de Signed, este a su vez hereda de Real que hereda de Number el cual tiene hereda del tipo base Any.

En este árbol hay tipos de datos que son abstractos como es el caso de Signed, Real y Number. Lo que significa que no se pueden existir instancias de objetos de este tipo. Un concepto que conciso para los que estén familiarizados con los conceptos de la programación orientada a objetos (POO). Para los que no están facilitados con la POO, los tipos abstractos solo son un “nombre” que permite agrupar a diferentes subtipos, pero puede usarse como una anotación de tipo.

Esto es algo que se puede ver en el siguiente ejemplo.

n::Integer = 12
typeof(n) # Int64

El valor que devuelve typeof es Int64 no Integer porque este ultimo es abstracto. Pero este código no permite evitar que se asigne un valor real a n, ya que ningún Float hereda de Integer.

n::Integer = 12.10 # InexactError: Int64(12.1)

Tipos definidos por el usuario

Como ya hemos visto al hablar de las estructuras es posible crear tipos de datos en Julia personalizados, combinando los tipos de datos del lenguaje. Siguiendo con el ejemplo de la entrada anterior, se puede crear un tipo de dato Punto con dos valores reales.

struct Punto
    x::Float64
    y::Float64
end

p = Punto(1, 2)

Las estructuras de Julia son como objetos sin métodos lenguajes como C# o Java. Formados únicamente por propiedades.

A diferencia de otros lenguajes orientados a objetos como Python o Java, donde se llama a una función de un objeto como mediante la notación punto object.func(args) en Julia usa la sintaxis func(object, args). Una notación similar a las clases S3 de R. Esto es así porque Julia no tiene clases, por lo que se mantienen separados los datos de las funciones.

Si necesitamos conocer el nombre de las propiedades de una estructura podemos usar la función fieldnames. Aplicándolo a la estructura de ejemplo se puede usar fieldnames(Punto) o fieldnames(typeof(p)) para obtener (:x, :y).

¿Cuándo dos valores son iguales o diferentes?

En Julia existen dos operadores de comparación. El primero eso == y nos indica si los dos valores son iguales. Por otro lado, existe un operador con tres signos de igualdad === que comprueba si los dos son el mismo objeto. Por ejemplo, si comparamos un valor entero son su versión real == devolverá verdadero, mientras que === devolverá falso.

10 == Float64(10)  # true
10 === Float64(10) # false

En el caso de estructuras la comparación es más compleja. Ya que dependerá de si el tipo es mutable o no. En el caso de las estructuras inmutables Julia optimiza los recursos y si se crea dos objetos iguales usará la misma instancia, por eso tanto el operador == como === devuelven el valor verdadero.

struct Punto
    x::Float64
    y::Float64
end

p1 = Punto(1, 2)
p2 = Punto(1, 2)

p1 == p2  # true
p1 === p2 # true

Por otro lado, cuando es mutable en cada ocasión se crea un objeto diferente, por lo que ambos operadores devuelven falso en esta ocasión.

mutable struct PuntoMutable
    x::Float64
    y::Float64
end

p1 = PuntoMutable(1, 2)
p2 = PuntoMutable(1, 2)

p1 == p2  # false
p1 === p2 # false

Esto es así porque los objetos son objetos diferentes, aunque los datos sean los mismos, y no se ha definido una función para el operador de comparación. Algo que se puede hacer fácilmente como se muestra a continuación.

function Base.:(==)(p1::PuntoMutable, p2::PuntoMutable) 
    return p1.x == p2.x && p1.y == p2.y
end

p1 == p2 # true

Unión de tipos

Anteriormente hemos creado dos tipos de datos que implementan un punto: Puntoy PuntoMutable. En el caso de que queremos hacer una operación sobre ellos es necesario sobrecargar el operador para todos los casos posibles. Esto es:

import Base.:+ 

+(p::Punto, q::Punto) = Punto(p.x + q.x, p.y + q.y)
+(p::PuntoMutable, q::PuntoMutable) = Punto(p.x + q.x, p.y + q.y)
+(p::Punto, q::PuntoMutable) = Punto(p.x + q.x, p.y + q.y)
+(p::PuntoMutable, q::Punto) = Punto(p.x + q.x, p.y + q.y)

p1 = Punto(1, 2)
p2 = PuntoMutable(3, 4)

p1 + p2 # Punto(4.0, 6.0)

Pero esto puede ser un poco tediosos, ya que es necesario escribir el mismo método cuatro veces. Esto se puede simplificar definiendo una unión de tipos, para que así se puede usar uno u otro de forma indiferente en las definiciones. En nuestro caso podemos crear la unión MiPunto que se puede usar como un tipo a la hora de definir funciones.

MiPunto = Union{Punto, PuntoMutable}

+(p::MiPunto, q::MiPunto) = Punto(p.x + q.x, p.y + q.y)

p1 + p2

Esto no es solo útil para la sobrecarga de operadores, sino que también para las funciones.

Conclusiones

Hoy hemos visto más en profundidad los tipos de datos en Julia. Cómo heredan unos de otros y cómo podemos comparar que dos datos son el mismo. Finalmente hemos visto por que en las estructuras mutables cuando definimos dos con los mismos valores Julia nos indica que son iguales y el mismo objeto. Mientras que si son inmutables la comparación es siempre falsa, salvo que se defina sobrescriba el operador de igualdad.

Publicaciones de la serie ¡Hola Julia!

1. ¡Hola Julia!
2. Primeros pasos con Julia
3. Cadenas de texto en Julia
4. Bucles en Julia
5. Funciones en Julia
6. Vectores, tuplas y diccionarios en Julia
7. Estructuras en Julia
8. Utilizar los tipos en Julia
9. Tipos de datos en Julia
10. Tipos y funciones paramétricos en Julia
11. Introducción a los DataFrames en Julia
12. Obtener información básica de los DataFrames de Julia
13. El tipo de dato Missing de Julia
14. Columnas en DataFrames de Julia
15. Filas en DataFrames de Julia
16. Combinar DataFrames en Julia
17. Guardar y leer archivos CSV en Julia
18. Guardar y leer archivos Excel en Julia
19. Introducción a Genie
20. Libros sobre Julia